/*++ BUILD Version: 0010 // Increment this if a change has global effects Copyright (c) Microsoft Corporation. All rights reserved. Module Name: wudfwdm.h Abstract: This module defines the WDM types, constants, and functions available to User Mode Driver Framework (UMDF) device drivers. Revision History: --*/ #pragma once #ifdef __cplusplus extern "C" { #endif typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT; typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT; typedef struct _FILE_OBJECT *PFILE_OBJECT; typedef struct _INTERFACE *PINTERFACE; typedef struct _IO_SECURITY_CONTEXT *PIO_SECURITY_CONTEXT; typedef struct _IO_STATUS_BLOCK *PIO_STATUS_BLOCK; typedef struct _KTHREAD *PKTHREAD, *PRKTHREAD; #define PMDL PVOID #define PIRP PVOID typedef enum _DEVICE_RELATION_TYPE DEVICE_RELATION_TYPE, *PDEVICE_RELATION_TYPE; #define PAGED_CODE() #define PAGED_CODE_LOCKED() #ifndef _MANAGED #if defined(_M_IX86) #define FASTCALL __fastcall #else #define FASTCALL #endif #else #define FASTCALL NTAPI #endif // // NTSTATUS // typedef _Return_type_success_(return >= 0) LONG NTSTATUS; /*lint -save -e624 */ // Don't complain about different typedefs. typedef NTSTATUS *PNTSTATUS; /*lint -restore */ // Resume checking for different typedefs. #if _WIN32_WINNT >= 0x0600 typedef CONST NTSTATUS *PCNTSTATUS; #endif // _WIN32_WINNT >= 0x0600 // // Status values are 32 bit values laid out as follows: // // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 // +---+-+-------------------------+-------------------------------+ // |Sev|C| Facility | Code | // +---+-+-------------------------+-------------------------------+ // // where // // Sev - is the severity code // // 00 - Success // 01 - Informational // 10 - Warning // 11 - Error // // C - is the Customer code flag // // Facility - is the facility code // // Code - is the facility's status code // // // Generic test for success on any status value (non-negative numbers // indicate success). // #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) // // Generic test for information on any status value. // #ifdef _PREFAST_ #define NT_INFORMATION(Status) (((NTSTATUS)(Status)) >= (long)0x40000000) #else #define NT_INFORMATION(Status) ((((ULONG)(Status)) >> 30) == 1) #endif // // Generic test for warning on any status value. // #ifdef _PREFAST_ #define NT_WARNING(Status) (((NTSTATUS)(Status) < (long)0xc0000000)) #else #define NT_WARNING(Status) ((((ULONG)(Status)) >> 30) == 2) #endif // // Generic test for error on any status value. // #ifdef _PREFAST_ #define NT_ERROR(Status) (((NTSTATUS)(Status)) >= (unsigned long)0xc0000000) #else #define NT_ERROR(Status) ((((ULONG)(Status)) >> 30) == 3) #endif // // Physical address. // typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS; // // Event type // typedef enum _EVENT_TYPE { NotificationEvent, SynchronizationEvent } EVENT_TYPE; // // Pointer to an Asciiz string // typedef _Null_terminated_ CHAR *PSZ; typedef _Null_terminated_ CONST char *PCSZ; // // Counted String // typedef USHORT RTL_STRING_LENGTH_TYPE; typedef struct _STRING { USHORT Length; USHORT MaximumLength; #ifdef MIDL_PASS [size_is(MaximumLength), length_is(Length) ] #endif // MIDL_PASS _Field_size_bytes_part_opt_(MaximumLength, Length) PCHAR Buffer; } STRING; typedef STRING *PSTRING; typedef STRING ANSI_STRING; typedef PSTRING PANSI_STRING; typedef STRING CANSI_STRING; typedef PSTRING PCANSI_STRING; typedef STRING UTF8_STRING; typedef PSTRING PUTF8_STRING; // // Unicode strings are counted 16-bit character strings. If they are // NULL terminated, Length does not include trailing NULL. // typedef struct _UNICODE_STRING { USHORT Length; USHORT MaximumLength; #ifdef MIDL_PASS [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT * Buffer; #else // MIDL_PASS _Field_size_bytes_part_opt_(MaximumLength, Length) PWCH Buffer; #endif // MIDL_PASS } UNICODE_STRING; typedef UNICODE_STRING *PUNICODE_STRING; typedef const UNICODE_STRING *PCUNICODE_STRING; #define DECLARE_CONST_UNICODE_STRING(_var, _string) \ const WCHAR _var ## _buffer[] = _string; \ __pragma(warning(push)) \ __pragma(warning(disable:4221)) __pragma(warning(disable:4204)) \ const UNICODE_STRING _var = { sizeof(_string) - sizeof(WCHAR), sizeof(_string), (PWCH) _var ## _buffer } \ __pragma(warning(pop)) #define DECLARE_GLOBAL_CONST_UNICODE_STRING(_var, _str) \ extern const __declspec(selectany) UNICODE_STRING _var = RTL_CONSTANT_STRING(_str) #define DECLARE_UNICODE_STRING_SIZE(_var, _size) \ WCHAR _var ## _buffer[_size]; \ __pragma(warning(push)) \ __pragma(warning(disable:4221)) __pragma(warning(disable:4204)) \ UNICODE_STRING _var = { 0, (_size) * sizeof(WCHAR) , _var ## _buffer } \ __pragma(warning(pop)) // // Valid values for the Attributes field // #define OBJ_INHERIT 0x00000002L #define OBJ_PERMANENT 0x00000010L #define OBJ_EXCLUSIVE 0x00000020L #define OBJ_CASE_INSENSITIVE 0x00000040L #define OBJ_OPENIF 0x00000080L #define OBJ_OPENLINK 0x00000100L #define OBJ_KERNEL_HANDLE 0x00000200L #define OBJ_FORCE_ACCESS_CHECK 0x00000400L #define OBJ_IGNORE_IMPERSONATED_DEVICEMAP 0x00000800L #define OBJ_DONT_REPARSE 0x00001000L #define OBJ_VALID_ATTRIBUTES 0x00001FF2L typedef struct _OBJECT_ATTRIBUTES { ULONG Length; HANDLE RootDirectory; PUNICODE_STRING ObjectName; ULONG Attributes; PVOID SecurityDescriptor; // Points to type SECURITY_DESCRIPTOR PVOID SecurityQualityOfService; // Points to type SECURITY_QUALITY_OF_SERVICE } OBJECT_ATTRIBUTES; typedef OBJECT_ATTRIBUTES *POBJECT_ATTRIBUTES; typedef CONST OBJECT_ATTRIBUTES *PCOBJECT_ATTRIBUTES; //++ // // VOID // InitializeObjectAttributes( // _Out_ POBJECT_ATTRIBUTES p, // _In_ PUNICODE_STRING n, // _In_ ULONG a, // _In_ HANDLE r, // _In_ PSECURITY_DESCRIPTOR s // ) // //-- #define InitializeObjectAttributes( p, n, a, r, s ) { \ (p)->Length = sizeof( OBJECT_ATTRIBUTES ); \ (p)->RootDirectory = r; \ (p)->Attributes = a; \ (p)->ObjectName = n; \ (p)->SecurityDescriptor = s; \ (p)->SecurityQualityOfService = NULL; \ } // // Determine if an argument is present by testing the value of the pointer // to the argument value. // #define ARGUMENT_PRESENT(ArgumentPointer) (\ (CHAR *)((ULONG_PTR)(ArgumentPointer)) != (CHAR *)(NULL) ) // // Interrupt Request Level (IRQL) // typedef UCHAR KIRQL; typedef KIRQL *PKIRQL; // // Interrupt modes. // typedef enum _KINTERRUPT_MODE { LevelSensitive, Latched } KINTERRUPT_MODE; typedef enum _MEMORY_CACHING_TYPE_ORIG { MmFrameBufferCached = 2 } MEMORY_CACHING_TYPE_ORIG; typedef enum _MEMORY_CACHING_TYPE { MmNonCached = FALSE, MmCached = TRUE, MmWriteCombined = MmFrameBufferCached, MmHardwareCoherentCached, MmNonCachedUnordered, // IA64 MmUSWCCached, MmMaximumCacheType, MmNotMapped = -1 } MEMORY_CACHING_TYPE; // // Define the major function codes for IRPs. // #define IRP_MJ_CREATE 0x00 #define IRP_MJ_CREATE_NAMED_PIPE 0x01 #define IRP_MJ_CLOSE 0x02 #define IRP_MJ_READ 0x03 #define IRP_MJ_WRITE 0x04 #define IRP_MJ_QUERY_INFORMATION 0x05 #define IRP_MJ_SET_INFORMATION 0x06 #define IRP_MJ_QUERY_EA 0x07 #define IRP_MJ_SET_EA 0x08 #define IRP_MJ_FLUSH_BUFFERS 0x09 #define IRP_MJ_QUERY_VOLUME_INFORMATION 0x0a #define IRP_MJ_SET_VOLUME_INFORMATION 0x0b #define IRP_MJ_DIRECTORY_CONTROL 0x0c #define IRP_MJ_FILE_SYSTEM_CONTROL 0x0d #define IRP_MJ_DEVICE_CONTROL 0x0e #define IRP_MJ_INTERNAL_DEVICE_CONTROL 0x0f #define IRP_MJ_SHUTDOWN 0x10 #define IRP_MJ_LOCK_CONTROL 0x11 #define IRP_MJ_CLEANUP 0x12 #define IRP_MJ_CREATE_MAILSLOT 0x13 #define IRP_MJ_QUERY_SECURITY 0x14 #define IRP_MJ_SET_SECURITY 0x15 #define IRP_MJ_POWER 0x16 #define IRP_MJ_SYSTEM_CONTROL 0x17 #define IRP_MJ_DEVICE_CHANGE 0x18 #define IRP_MJ_QUERY_QUOTA 0x19 #define IRP_MJ_SET_QUOTA 0x1a #define IRP_MJ_PNP 0x1b #define IRP_MJ_PNP_POWER IRP_MJ_PNP // Obsolete.... #define IRP_MJ_MAXIMUM_FUNCTION 0x1b // // Make the Scsi major code the same as internal device control. // #define IRP_MJ_SCSI IRP_MJ_INTERNAL_DEVICE_CONTROL // // Define the minor function codes for IRPs. The lower 128 codes, from 0x00 to // 0x7f are reserved to Microsoft. The upper 128 codes, from 0x80 to 0xff, are // reserved to customers of Microsoft. // #if defined(_WIN64) #define POINTER_ALIGNMENT DECLSPEC_ALIGN(8) #else #define POINTER_ALIGNMENT #endif // // Define driver initialization routine type. // _Function_class_(DRIVER_INITIALIZE) _IRQL_requires_same_ _IRQL_requires_(PASSIVE_LEVEL) typedef NTSTATUS DRIVER_INITIALIZE ( _In_ struct _DRIVER_OBJECT *DriverObject, _In_ PUNICODE_STRING RegistryPath ); typedef DRIVER_INITIALIZE *PDRIVER_INITIALIZE; // // \Callback\PowerState values // #define PO_CB_SYSTEM_POWER_POLICY 0 #define PO_CB_AC_STATUS 1 #define PO_CB_BUTTON_COLLISION 2 // deprecated #define PO_CB_SYSTEM_STATE_LOCK 3 #define PO_CB_LID_SWITCH_STATE 4 #define PO_CB_PROCESSOR_POWER_POLICY 5 // deprecated // // Runtime Power Management Framework // #define PO_FX_VERSION_V1 0x00000001 #define PO_FX_VERSION_V2 0x00000002 #define PO_FX_VERSION PO_FX_VERSION_V1 DECLARE_HANDLE(POHANDLE); typedef _Function_class_(PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK ( _In_ PVOID Context, _In_ ULONG Component ); typedef PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK *PPO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK; typedef _Function_class_(PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK ( _In_ PVOID Context, _In_ ULONG Component ); typedef PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK *PPO_FX_COMPONENT_IDLE_CONDITION_CALLBACK; typedef _Function_class_(PO_FX_COMPONENT_IDLE_STATE_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_COMPONENT_IDLE_STATE_CALLBACK ( _In_ PVOID Context, _In_ ULONG Component, _In_ ULONG State ); typedef PO_FX_COMPONENT_IDLE_STATE_CALLBACK *PPO_FX_COMPONENT_IDLE_STATE_CALLBACK; typedef _Function_class_(PO_FX_DEVICE_POWER_REQUIRED_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_DEVICE_POWER_REQUIRED_CALLBACK ( _In_ PVOID Context ); typedef PO_FX_DEVICE_POWER_REQUIRED_CALLBACK *PPO_FX_DEVICE_POWER_REQUIRED_CALLBACK; typedef _Function_class_(PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK ( _In_ PVOID Context ); typedef PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK *PPO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK; typedef _Function_class_(PO_FX_POWER_CONTROL_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS PO_FX_POWER_CONTROL_CALLBACK ( _In_ PVOID DeviceContext, _In_ LPCGUID PowerControlCode, _In_reads_bytes_opt_(InBufferSize) PVOID InBuffer, _In_ SIZE_T InBufferSize, _Out_writes_bytes_opt_(OutBufferSize) PVOID OutBuffer, _In_ SIZE_T OutBufferSize, _Out_opt_ PSIZE_T BytesReturned ); typedef PO_FX_POWER_CONTROL_CALLBACK *PPO_FX_POWER_CONTROL_CALLBACK; typedef _Function_class_(PO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK) _IRQL_requires_max_(HIGH_LEVEL) VOID PO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK ( _In_ PVOID Context, _In_ ULONG Component, _In_ BOOLEAN Active ); typedef PO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK *PPO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK; typedef struct _PO_FX_COMPONENT_IDLE_STATE { ULONGLONG TransitionLatency; ULONGLONG ResidencyRequirement; ULONG NominalPower; } PO_FX_COMPONENT_IDLE_STATE, *PPO_FX_COMPONENT_IDLE_STATE; typedef struct _PO_FX_COMPONENT_V1 { GUID Id; ULONG IdleStateCount; ULONG DeepestWakeableIdleState; _Field_size_full_(IdleStateCount) PPO_FX_COMPONENT_IDLE_STATE IdleStates; } PO_FX_COMPONENT_V1, *PPO_FX_COMPONENT_V1; typedef struct _PO_FX_DEVICE_V1 { ULONG Version; ULONG ComponentCount; PPO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK ComponentActiveConditionCallback; PPO_FX_COMPONENT_IDLE_CONDITION_CALLBACK ComponentIdleConditionCallback; PPO_FX_COMPONENT_IDLE_STATE_CALLBACK ComponentIdleStateCallback; PPO_FX_DEVICE_POWER_REQUIRED_CALLBACK DevicePowerRequiredCallback; PPO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK DevicePowerNotRequiredCallback; PPO_FX_POWER_CONTROL_CALLBACK PowerControlCallback; PVOID DeviceContext; _Field_size_full_(ComponentCount) PO_FX_COMPONENT_V1 Components[ANYSIZE_ARRAY]; } PO_FX_DEVICE_V1, *PPO_FX_DEVICE_V1; #define PO_FX_COMPONENT_FLAG_F0_ON_DX 0x0000000000000001 #define PO_FX_COMPONENT_FLAG_NO_DEBOUNCE 0x0000000000000002 typedef struct _PO_FX_COMPONENT_V2 { GUID Id; ULONGLONG Flags; ULONG DeepestWakeableIdleState; ULONG IdleStateCount; _Field_size_full_(IdleStateCount) PPO_FX_COMPONENT_IDLE_STATE IdleStates; ULONG ProviderCount; _Field_size_full_(ProviderCount) PULONG Providers; } PO_FX_COMPONENT_V2, *PPO_FX_COMPONENT_V2; typedef struct _PO_FX_DEVICE_V2 { ULONG Version; ULONGLONG Flags; PPO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK ComponentActiveConditionCallback; PPO_FX_COMPONENT_IDLE_CONDITION_CALLBACK ComponentIdleConditionCallback; PPO_FX_COMPONENT_IDLE_STATE_CALLBACK ComponentIdleStateCallback; PPO_FX_DEVICE_POWER_REQUIRED_CALLBACK DevicePowerRequiredCallback; PPO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK DevicePowerNotRequiredCallback; PPO_FX_POWER_CONTROL_CALLBACK PowerControlCallback; PVOID DeviceContext; ULONG ComponentCount; _Field_size_full_(ComponentCount) PO_FX_COMPONENT_V2 Components[ANYSIZE_ARRAY]; } PO_FX_DEVICE_V2, *PPO_FX_DEVICE_V2; #if (PO_FX_VERSION == PO_FX_VERSION_V1) typedef PO_FX_COMPONENT_V1 PO_FX_COMPONENT, *PPO_FX_COMPONENT; typedef PO_FX_DEVICE_V1 PO_FX_DEVICE, *PPO_FX_DEVICE; #elif (PO_FX_VERSION == PO_FX_VERSION_V2) typedef PO_FX_COMPONENT_V2 PO_FX_COMPONENT, *PPO_FX_COMPONENT; typedef PO_FX_DEVICE_V2 PO_FX_DEVICE, *PPO_FX_DEVICE; #else #error PO_FX_VERSION undefined! #endif typedef enum _PO_FX_PERF_STATE_UNIT { PoFxPerfStateUnitOther, PoFxPerfStateUnitFrequency, PoFxPerfStateUnitBandwidth, PoFxPerfStateUnitMaximum } PO_FX_PERF_STATE_UNIT, *PPO_FX_PERF_STATE_UNIT; typedef enum _PO_FX_PERF_STATE_TYPE { PoFxPerfStateTypeDiscrete, PoFxPerfStateTypeRange, PoFxPerfStateTypeMaximum } PO_FX_PERF_STATE_TYPE, *PPO_FX_PERF_STATE_TYPE; typedef struct _PO_FX_PERF_STATE { ULONGLONG Value; PVOID Context; } PO_FX_PERF_STATE, *PPO_FX_PERF_STATE; typedef struct _PO_FX_COMPONENT_PERF_SET { UNICODE_STRING Name; ULONGLONG Flags; PO_FX_PERF_STATE_UNIT Unit; PO_FX_PERF_STATE_TYPE Type; union { struct { ULONG Count; _Field_size_full_(Count) PPO_FX_PERF_STATE States; } Discrete; struct { ULONGLONG Minimum; ULONGLONG Maximum; } Range; }; } PO_FX_COMPONENT_PERF_SET, *PPO_FX_COMPONENT_PERF_SET; typedef struct _PO_FX_COMPONENT_PERF_INFO { ULONG PerfStateSetsCount; PO_FX_COMPONENT_PERF_SET PerfStateSets[ANYSIZE_ARRAY]; } PO_FX_COMPONENT_PERF_INFO, *PPO_FX_COMPONENT_PERF_INFO; typedef struct _PO_FX_PERF_STATE_CHANGE { ULONG Set; union { ULONG StateIndex; ULONGLONG StateValue; }; } PO_FX_PERF_STATE_CHANGE, *PPO_FX_PERF_STATE_CHANGE; // // Pool Allocation routines (in pool.c) // typedef _Enum_is_bitflag_ enum _POOL_TYPE { NonPagedPool, NonPagedPoolExecute = NonPagedPool, PagedPool, NonPagedPoolMustSucceed = NonPagedPool + 2, DontUseThisType, NonPagedPoolCacheAligned = NonPagedPool + 4, PagedPoolCacheAligned, NonPagedPoolCacheAlignedMustS = NonPagedPool + 6, MaxPoolType, // // Define base types for NonPaged (versus Paged) pool, for use in cracking // the underlying pool type. // NonPagedPoolBase = 0, NonPagedPoolBaseMustSucceed = NonPagedPoolBase + 2, NonPagedPoolBaseCacheAligned = NonPagedPoolBase + 4, NonPagedPoolBaseCacheAlignedMustS = NonPagedPoolBase + 6, // // Note these per session types are carefully chosen so that the appropriate // masking still applies as well as MaxPoolType above. // NonPagedPoolSession = 32, PagedPoolSession = NonPagedPoolSession + 1, NonPagedPoolMustSucceedSession = PagedPoolSession + 1, DontUseThisTypeSession = NonPagedPoolMustSucceedSession + 1, NonPagedPoolCacheAlignedSession = DontUseThisTypeSession + 1, PagedPoolCacheAlignedSession = NonPagedPoolCacheAlignedSession + 1, NonPagedPoolCacheAlignedMustSSession = PagedPoolCacheAlignedSession + 1, NonPagedPoolNx = 512, NonPagedPoolNxCacheAligned = NonPagedPoolNx + 4, NonPagedPoolSessionNx = NonPagedPoolNx + 32, } _Enum_is_bitflag_ POOL_TYPE; #define POOL_COLD_ALLOCATION 256 // Note this cannot encode into the header. #define POOL_NX_ALLOCATION 512 // Note this cannot encode into the header. // // Define PnP Device Property for IoGetDeviceProperty // #ifdef _PREFAST_ #define __string_type 0x1000 #define __guid_type 0x2000 #define __multiString_type 0x4000 #else #define __string_type 0 #define __guid_type 0 #define __multiString_type 0 #endif typedef enum { DevicePropertyDeviceDescription = 0x0 | __string_type, DevicePropertyHardwareID = 0x1 | __multiString_type, DevicePropertyCompatibleIDs = 0x2 | __multiString_type, DevicePropertyBootConfiguration = 0x3, DevicePropertyBootConfigurationTranslated = 0x4, DevicePropertyClassName = 0x5 | __string_type, DevicePropertyClassGuid = 0x6 | __string_type, DevicePropertyDriverKeyName = 0x7 | __string_type, DevicePropertyManufacturer = 0x8 | __string_type, DevicePropertyFriendlyName = 0x9 | __string_type, DevicePropertyLocationInformation = 0xa | __string_type, DevicePropertyPhysicalDeviceObjectName = 0xb | __string_type, DevicePropertyBusTypeGuid = 0xc | __guid_type, DevicePropertyLegacyBusType = 0xd, DevicePropertyBusNumber = 0xe, DevicePropertyEnumeratorName = 0xf | __string_type, DevicePropertyAddress = 0x10, DevicePropertyUINumber = 0x11, DevicePropertyInstallState = 0x12, DevicePropertyRemovalPolicy = 0x13, DevicePropertyResourceRequirements = 0x14, DevicePropertyAllocatedResources = 0x15, DevicePropertyContainerID = 0x16 | __string_type } DEVICE_REGISTRY_PROPERTY; // // The following definitions are used in IoOpenDeviceRegistryKey // #define PLUGPLAY_REGKEY_DEVICE 1 #define PLUGPLAY_REGKEY_DRIVER 2 #define PLUGPLAY_REGKEY_CURRENT_HWPROFILE 4 #if (NTDDI_VERSION >= NTDDI_VISTA) // // Custom device properties... // #include // // Definitions of property flags. // #define PLUGPLAY_PROPERTY_PERSISTENT 0x00000001 #endif // // Processor modes. // typedef CCHAR KPROCESSOR_MODE; typedef enum _MODE { KernelMode, UserMode, MaximumMode } MODE; #if defined(_X86_) // // i386 Specific portions of Mm component. // // Define the page size for the Intel 386 as 4096 (0x1000). // #define PAGE_SIZE 0x1000 // // Define the number of trailing zeros in a page aligned virtual address. // This is used as the shift count when shifting virtual addresses to // virtual page numbers. // #define PAGE_SHIFT 12L #elif defined(_AMD64_) // // AMD64 Specific portions of Mm component. // // Define the page size for the AMD64 as 4096 (0x1000). // #define PAGE_SIZE 0x1000 // // Define the number of trailing zeros in a page aligned virtual address. // This is used as the shift count when shifting virtual addresses to // virtual page numbers. // #define PAGE_SHIFT 12L #elif defined(_ARM64_) // // ARM Specific portions of Mm component. // // Define the page size for the ARM64 as 4096 (0x1000). // #define PAGE_SIZE 0x1000 // // Define the number of trailing zeros in a page aligned virtual address. // This is used as the shift count when shifting virtual addresses to // virtual page numbers. // #define PAGE_SHIFT 12L #elif defined(_ARM_) // // ARM Specific portions of Mm component. // // Define the page size for the ARM as 4096 (0x1000). // #define PAGE_SIZE 0x1000 // // Define the number of trailing zeros in a page aligned virtual address. // This is used as the shift count when shifting virtual addresses to // virtual page numbers. // #define PAGE_SHIFT 12L #endif // // Priority increment definitions. The comment for each definition gives // the names of the system services that use the definition when satisfying // a wait. // // // Priority increment used when satisfying a wait on an executive event // (NtPulseEvent and NtSetEvent) // #define EVENT_INCREMENT 1 // // Priority increment when no I/O has been done. This is used by device // and file system drivers when completing an IRP (IoCompleteRequest). // #define IO_NO_INCREMENT 0 // // Priority increment for completing CD-ROM I/O. This is used by CD-ROM device // and file system drivers when completing an IRP (IoCompleteRequest) // #define IO_CD_ROM_INCREMENT 1 // // Priority increment for completing disk I/O. This is used by disk device // and file system drivers when completing an IRP (IoCompleteRequest) // #define IO_DISK_INCREMENT 1 // // Priority increment for completing keyboard I/O. This is used by keyboard // device drivers when completing an IRP (IoCompleteRequest) // #define IO_KEYBOARD_INCREMENT 6 // // Priority increment for completing mailslot I/O. This is used by the mail- // slot file system driver when completing an IRP (IoCompleteRequest). // #define IO_MAILSLOT_INCREMENT 2 // // Priority increment for completing mouse I/O. This is used by mouse device // drivers when completing an IRP (IoCompleteRequest) // #define IO_MOUSE_INCREMENT 6 // // Priority increment for completing named pipe I/O. This is used by the // named pipe file system driver when completing an IRP (IoCompleteRequest). // #define IO_NAMED_PIPE_INCREMENT 2 // // Priority increment for completing network I/O. This is used by network // device and network file system drivers when completing an IRP // (IoCompleteRequest). // #define IO_NETWORK_INCREMENT 2 // // Priority increment for completing parallel I/O. This is used by parallel // device drivers when completing an IRP (IoCompleteRequest) // #define IO_PARALLEL_INCREMENT 1 // // Priority increment for completing serial I/O. This is used by serial device // drivers when completing an IRP (IoCompleteRequest) // #define IO_SERIAL_INCREMENT 2 // // Priority increment for completing sound I/O. This is used by sound device // drivers when completing an IRP (IoCompleteRequest) // #define IO_SOUND_INCREMENT 8 // // Priority increment for completing video I/O. This is used by video device // drivers when completing an IRP (IoCompleteRequest) // #define IO_VIDEO_INCREMENT 1 // // Priority increment used when satisfying a wait on an executive semaphore // (NtReleaseSemaphore) // #define SEMAPHORE_INCREMENT 1 #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _At_(String->MaximumLength, _Const_) NTSYSAPI NTSTATUS NTAPI RtlIntegerToUnicodeString ( _In_ ULONG Value, _In_opt_ ULONG Base, _Inout_ PUNICODE_STRING String ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _At_(String->MaximumLength, _Const_) NTSYSAPI NTSTATUS NTAPI RtlInt64ToUnicodeString ( _In_ ULONGLONG Value, _In_opt_ ULONG Base, _Inout_ PUNICODE_STRING String ); #endif #ifdef _WIN64 #define RtlIntPtrToUnicodeString(Value, Base, String) RtlInt64ToUnicodeString(Value, Base, String) #else #define RtlIntPtrToUnicodeString(Value, Base, String) RtlIntegerToUnicodeString(Value, Base, String) #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToInteger ( _In_ PCUNICODE_STRING String, _In_opt_ ULONG Base, _Out_ PULONG Value ); #endif #if !defined(BLDR_KERNEL_RUNTIME) NTSTATUS RtlUnicodeStringToInt64 ( _In_ PCUNICODE_STRING String, _In_opt_ ULONG Base, _Out_ PLONG64 Number, _Out_opt_ PWSTR *EndPointer ); #endif _IRQL_requires_max_(DISPATCH_LEVEL) _At_(DestinationString->Buffer, _Post_equal_to_(SourceString)) _At_(DestinationString->Length, _Post_equal_to_(_String_length_(SourceString) * sizeof(WCHAR))) _At_(DestinationString->MaximumLength, _Post_equal_to_((_String_length_(SourceString)+1) * sizeof(WCHAR))) NTSYSAPI VOID NTAPI RtlInitUnicodeString( _Out_ PUNICODE_STRING DestinationString, _In_opt_z_ __drv_aliasesMem PCWSTR SourceString ); _At_(UnicodeString->Buffer, _Post_equal_to_(Buffer)) _At_(UnicodeString->Length, _Post_equal_to_(0)) _At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize)) FORCEINLINE VOID RtlInitEmptyUnicodeString( _Out_ PUNICODE_STRING UnicodeString, _Writable_bytes_(BufferSize) _When_(BufferSize != 0, _Notnull_) __drv_aliasesMem PWCHAR Buffer, _In_ USHORT BufferSize ) { UnicodeString->Length = 0; UnicodeString->MaximumLength = BufferSize; UnicodeString->Buffer = Buffer; } #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI LONG NTAPI RtlCompareUnicodeStrings( _In_reads_(String1Length) PCWCH String1, _In_ SIZE_T String1Length, _In_reads_(String2Length) PCWCH String2, _In_ SIZE_T String2Length, _In_ BOOLEAN CaseInSensitive ); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI LONG NTAPI RtlCompareUnicodeString( _In_ PCUNICODE_STRING String1, _In_ PCUNICODE_STRING String2, _In_ BOOLEAN CaseInSensitive ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString( _In_ PCUNICODE_STRING String1, _In_ PCUNICODE_STRING String2, _In_ BOOLEAN CaseInSensitive ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Unchanged_(DestinationString->Buffer) _Unchanged_(DestinationString->MaximumLength) _At_(DestinationString->Length, _When_(SourceString->Length > DestinationString->MaximumLength, _Post_equal_to_(DestinationString->MaximumLength)) _When_(SourceString->Length <= DestinationString->MaximumLength, _Post_equal_to_(SourceString->Length))) NTSYSAPI VOID NTAPI RtlCopyUnicodeString( _Inout_ PUNICODE_STRING DestinationString, _In_opt_ PCUNICODE_STRING SourceString ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(1) _Unchanged_(Destination->MaximumLength) _Unchanged_(Destination->Buffer) _When_(_Old_(Destination->Length) + Source->Length <= Destination->MaximumLength, _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + Source->Length)) _At_(return, _Out_range_(==, 0))) _When_(_Old_(Destination->Length) + Source->Length > Destination->MaximumLength, _Unchanged_(Destination->Length) _At_(return, _Out_range_(<, 0))) NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString ( _Inout_ PUNICODE_STRING Destination, _In_ PCUNICODE_STRING Source ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(1) _Unchanged_(Destination->MaximumLength) _Unchanged_(Destination->Buffer) _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) <= Destination->MaximumLength, _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR))) _At_(return, _Out_range_(==, 0))) _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) > Destination->MaximumLength, _Unchanged_(Destination->Length) _At_(return, _Out_range_(<, 0))) NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeToString ( _Inout_ PUNICODE_STRING Destination, _In_opt_z_ PCWSTR Source ); #endif _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI VOID NTAPI RtlFreeUnicodeString( _Inout_ _At_(UnicodeString->Buffer, _Frees_ptr_opt_) PUNICODE_STRING UnicodeString ); #if (NTDDI_VERSION >= NTDDI_WIN2K) #if (_MSC_FULL_VER >= 150030729) && !defined(IMPORT_NATIVE_DBG_BREAK) #define DbgBreakPoint __debugbreak #else __analysis_noreturn VOID NTAPI DbgBreakPoint( VOID ); #endif #endif #if DBG #define KdPrintEx(_x_) DbgPrintEx _x_ #define KdBreakPoint() DbgBreakPoint() #else #define KdPrintEx(_x_) #define KdBreakPoint() #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTSYSAPI ULONG __cdecl DbgPrintEx ( _In_ ULONG ComponentId, _In_ ULONG Level, _In_z_ _Printf_format_string_ PCSTR Format, ... ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) #include #endif #if !defined (NT_INCLUDED) // // Define the create disposition values // #define FILE_SUPERSEDE 0x00000000 #define FILE_OPEN 0x00000001 #define FILE_CREATE 0x00000002 #define FILE_OPEN_IF 0x00000003 #define FILE_OVERWRITE 0x00000004 #define FILE_OVERWRITE_IF 0x00000005 #define FILE_MAXIMUM_DISPOSITION 0x00000005 // // Define the create/open option flags // #define FILE_DIRECTORY_FILE 0x00000001 #define FILE_WRITE_THROUGH 0x00000002 #define FILE_SEQUENTIAL_ONLY 0x00000004 #define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008 #define FILE_SYNCHRONOUS_IO_ALERT 0x00000010 #define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020 #define FILE_NON_DIRECTORY_FILE 0x00000040 #define FILE_CREATE_TREE_CONNECTION 0x00000080 #define FILE_COMPLETE_IF_OPLOCKED 0x00000100 #define FILE_NO_EA_KNOWLEDGE 0x00000200 #define FILE_OPEN_REMOTE_INSTANCE 0x00000400 #define FILE_RANDOM_ACCESS 0x00000800 #define FILE_DELETE_ON_CLOSE 0x00001000 #define FILE_OPEN_BY_FILE_ID 0x00002000 #define FILE_OPEN_FOR_BACKUP_INTENT 0x00004000 #define FILE_NO_COMPRESSION 0x00008000 #if (NTDDI_VERSION >= NTDDI_WIN7) #define FILE_OPEN_REQUIRING_OPLOCK 0x00010000 #define FILE_DISALLOW_EXCLUSIVE 0x00020000 #endif /* NTDDI_VERSION >= NTDDI_WIN7 */ #if (NTDDI_VERSION >= NTDDI_WIN8) #define FILE_SESSION_AWARE 0x00040000 #endif /* NTDDI_VERSION >= NTDDI_WIN8 */ #define FILE_RESERVE_OPFILTER 0x00100000 #define FILE_OPEN_REPARSE_POINT 0x00200000 #define FILE_OPEN_NO_RECALL 0x00400000 #define FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000 // // Define the base asynchronous I/O argument types // typedef struct _IO_STATUS_BLOCK { union { NTSTATUS Status; PVOID Pointer; } DUMMYUNIONNAME; ULONG_PTR Information; } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK; // // Define the I/O bus interface types. // typedef enum _INTERFACE_TYPE { InterfaceTypeUndefined = -1, Internal, Isa, Eisa, MicroChannel, TurboChannel, PCIBus, VMEBus, NuBus, PCMCIABus, CBus, MPIBus, MPSABus, ProcessorInternal, InternalPowerBus, PNPISABus, PNPBus, Vmcs, ACPIBus, MaximumInterfaceType }INTERFACE_TYPE, *PINTERFACE_TYPE; // // Resource List definitions // // // Defines the Type in the RESOURCE_DESCRIPTOR // // NOTE: For all CM_RESOURCE_TYPE values, there must be a // corresponding ResType value in the 32-bit ConfigMgr headerfile // (cfgmgr32.h). Values in the range [0x6,0x80) use the same values // as their ConfigMgr counterparts. CM_RESOURCE_TYPE values with // the high bit set (i.e., in the range [0x80,0xFF]), are // non-arbitrated resources. These correspond to the same values // in cfgmgr32.h that have their high bit set (however, since // cfgmgr32.h uses 16 bits for ResType values, these values are in // the range [0x8000,0x807F). Note that ConfigMgr ResType values // cannot be in the range [0x8080,0xFFFF), because they would not // be able to map into CM_RESOURCE_TYPE values. (0xFFFF itself is // a special value, because it maps to CmResourceTypeDeviceSpecific.) // typedef int CM_RESOURCE_TYPE; // CmResourceTypeNull is reserved #define CmResourceTypeNull 0 // ResType_All or ResType_None (0x0000) #define CmResourceTypePort 1 // ResType_IO (0x0002) #define CmResourceTypeInterrupt 2 // ResType_IRQ (0x0004) #define CmResourceTypeMemory 3 // ResType_Mem (0x0001) #define CmResourceTypeDma 4 // ResType_DMA (0x0003) #define CmResourceTypeDeviceSpecific 5 // ResType_ClassSpecific (0xFFFF) #define CmResourceTypeBusNumber 6 // ResType_BusNumber (0x0006) #define CmResourceTypeMemoryLarge 7 // ResType_MemLarge (0x0007) #define CmResourceTypeNonArbitrated 128 // Not arbitrated if 0x80 bit set #define CmResourceTypeConfigData 128 // ResType_Reserved (0x8000) #define CmResourceTypeDevicePrivate 129 // ResType_DevicePrivate (0x8001) #define CmResourceTypePcCardConfig 130 // ResType_PcCardConfig (0x8002) #define CmResourceTypeMfCardConfig 131 // ResType_MfCardConfig (0x8003) #define CmResourceTypeConnection 132 // ResType_Connection (0x8004) // // Defines the ShareDisposition in the RESOURCE_DESCRIPTOR // typedef enum _CM_SHARE_DISPOSITION { CmResourceShareUndetermined = 0, // Reserved CmResourceShareDeviceExclusive, CmResourceShareDriverExclusive, CmResourceShareShared } CM_SHARE_DISPOSITION; // // Define the bit masks for Flags when type is CmResourceTypeInterrupt // #define CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE 0x00 #define CM_RESOURCE_INTERRUPT_LATCHED 0x01 #define CM_RESOURCE_INTERRUPT_MESSAGE 0x02 #define CM_RESOURCE_INTERRUPT_POLICY_INCLUDED 0x04 #define CM_RESOURCE_INTERRUPT_SECONDARY_INTERRUPT 0x10 #define CM_RESOURCE_INTERRUPT_WAKE_HINT 0x20 // // A bitmask defining the bits in a resource or requirements descriptor // flags field that corresponds to the latch mode or a level triggered // interrupt. // #define CM_RESOURCE_INTERRUPT_LEVEL_LATCHED_BITS 0x0001 // // Define the token value used for an interrupt vector to mean that the vector // is message signaled. This value is used in the MaximumVector field. // #define CM_RESOURCE_INTERRUPT_MESSAGE_TOKEN ((ULONG)-2) // // Define the bit masks for Flags when type is CmResourceTypeMemory // or CmResourceTypeMemoryLarge // #define CM_RESOURCE_MEMORY_READ_WRITE 0x0000 #define CM_RESOURCE_MEMORY_READ_ONLY 0x0001 #define CM_RESOURCE_MEMORY_WRITE_ONLY 0x0002 #define CM_RESOURCE_MEMORY_WRITEABILITY_MASK 0x0003 #define CM_RESOURCE_MEMORY_PREFETCHABLE 0x0004 #define CM_RESOURCE_MEMORY_COMBINEDWRITE 0x0008 #define CM_RESOURCE_MEMORY_24 0x0010 #define CM_RESOURCE_MEMORY_CACHEABLE 0x0020 #define CM_RESOURCE_MEMORY_WINDOW_DECODE 0x0040 #define CM_RESOURCE_MEMORY_BAR 0x0080 #define CM_RESOURCE_MEMORY_COMPAT_FOR_INACCESSIBLE_RANGE 0x0100 // // Define the bit masks exclusive to type CmResourceTypeMemoryLarge. // #define CM_RESOURCE_MEMORY_LARGE 0x0E00 #define CM_RESOURCE_MEMORY_LARGE_40 0x0200 #define CM_RESOURCE_MEMORY_LARGE_48 0x0400 #define CM_RESOURCE_MEMORY_LARGE_64 0x0800 // // Define limits for large memory resources // #define CM_RESOURCE_MEMORY_LARGE_40_MAXLEN 0x000000FFFFFFFF00 #define CM_RESOURCE_MEMORY_LARGE_48_MAXLEN 0x0000FFFFFFFF0000 #define CM_RESOURCE_MEMORY_LARGE_64_MAXLEN 0xFFFFFFFF00000000 // // Define the bit masks for Flags when type is CmResourceTypePort // #define CM_RESOURCE_PORT_MEMORY 0x0000 #define CM_RESOURCE_PORT_IO 0x0001 #define CM_RESOURCE_PORT_10_BIT_DECODE 0x0004 #define CM_RESOURCE_PORT_12_BIT_DECODE 0x0008 #define CM_RESOURCE_PORT_16_BIT_DECODE 0x0010 #define CM_RESOURCE_PORT_POSITIVE_DECODE 0x0020 #define CM_RESOURCE_PORT_PASSIVE_DECODE 0x0040 #define CM_RESOURCE_PORT_WINDOW_DECODE 0x0080 #define CM_RESOURCE_PORT_BAR 0x0100 // // Define the bit masks for Flags when type is CmResourceTypeDma // #define CM_RESOURCE_DMA_8 0x0000 #define CM_RESOURCE_DMA_16 0x0001 #define CM_RESOURCE_DMA_32 0x0002 #define CM_RESOURCE_DMA_8_AND_16 0x0004 #define CM_RESOURCE_DMA_BUS_MASTER 0x0008 #define CM_RESOURCE_DMA_TYPE_A 0x0010 #define CM_RESOURCE_DMA_TYPE_B 0x0020 #define CM_RESOURCE_DMA_TYPE_F 0x0040 #define CM_RESOURCE_DMA_V3 0x0080 // // Define the different types of DMA transfer width values. // #define DMAV3_TRANFER_WIDTH_8 0x00 #define DMAV3_TRANFER_WIDTH_16 0x01 #define DMAV3_TRANFER_WIDTH_32 0x02 #define DMAV3_TRANFER_WIDTH_64 0x03 #define DMAV3_TRANFER_WIDTH_128 0x04 #define DMAV3_TRANFER_WIDTH_256 0x05 // // Define the Class and Type values for CmResourceTypeConnection // #define CM_RESOURCE_CONNECTION_CLASS_GPIO 0x01 #define CM_RESOURCE_CONNECTION_CLASS_SERIAL 0x02 #define CM_RESOURCE_CONNECTION_CLASS_FUNCTION_CONFIG 0x03 #define CM_RESOURCE_CONNECTION_TYPE_GPIO_IO 0x02 #define CM_RESOURCE_CONNECTION_TYPE_SERIAL_I2C 0x01 #define CM_RESOURCE_CONNECTION_TYPE_SERIAL_SPI 0x02 #define CM_RESOURCE_CONNECTION_TYPE_SERIAL_UART 0x03 #define CM_RESOURCE_CONNECTION_TYPE_FUNCTION_CONFIG 0x01 // // This structure defines one type of resource used by a driver. // // There can only be *1* DeviceSpecificData block. It must be located at // the end of all resource descriptors in a full descriptor block. // // // Make sure alignment is made properly by compiler; otherwise move // flags back to the top of the structure (common to all members of the // union). // #include "pshpack4.h" typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR { UCHAR Type; UCHAR ShareDisposition; USHORT Flags; union { // // Range of resources, inclusive. These are physical, bus relative. // It is known that Port and Memory below have the exact same layout // as Generic. // struct { PHYSICAL_ADDRESS Start; ULONG Length; } Generic; // // struct { PHYSICAL_ADDRESS Start; ULONG Length; } Port; // // struct { #if defined(NT_PROCESSOR_GROUPS) USHORT Level; USHORT Group; #else ULONG Level; #endif ULONG Vector; KAFFINITY Affinity; } Interrupt; // // Values for message signaled interrupts are distinct in the // raw and translated cases. // struct { union { struct { #if defined(NT_PROCESSOR_GROUPS) USHORT Group; #else USHORT Reserved; #endif USHORT MessageCount; ULONG Vector; KAFFINITY Affinity; } Raw; struct { #if defined(NT_PROCESSOR_GROUPS) USHORT Level; USHORT Group; #else ULONG Level; #endif ULONG Vector; KAFFINITY Affinity; } Translated; } DUMMYUNIONNAME; } MessageInterrupt; // // Range of memory addresses, inclusive. These are physical, bus // relative. The value should be the same as the one passed to // HalTranslateBusAddress(). // struct { PHYSICAL_ADDRESS Start; // 64 bit physical addresses. ULONG Length; } Memory; // // Physical DMA channel. // struct { ULONG Channel; ULONG Port; ULONG Reserved1; } Dma; struct { ULONG Channel; ULONG RequestLine; UCHAR TransferWidth; UCHAR Reserved1; UCHAR Reserved2; UCHAR Reserved3; } DmaV3; // // Device driver private data, usually used to help it figure // what the resource assignments decisions that were made. // struct { ULONG Data[3]; } DevicePrivate; // // Bus Number information. // struct { ULONG Start; ULONG Length; ULONG Reserved; } BusNumber; // // Device Specific information defined by the driver. // The DataSize field indicates the size of the data in bytes. The // data is located immediately after the DeviceSpecificData field in // the structure. // struct { ULONG DataSize; ULONG Reserved1; ULONG Reserved2; } DeviceSpecificData; // The following structures provide support for memory-mapped // IO resources greater than MAXULONG struct { PHYSICAL_ADDRESS Start; ULONG Length40; } Memory40; struct { PHYSICAL_ADDRESS Start; ULONG Length48; } Memory48; struct { PHYSICAL_ADDRESS Start; ULONG Length64; } Memory64; struct { UCHAR Class; UCHAR Type; UCHAR Reserved1; UCHAR Reserved2; ULONG IdLowPart; ULONG IdHighPart; } Connection; } u; } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR; #include "poppack.h" // // A Partial Resource List is what can be found in the ARC firmware // or will be generated by ntdetect.com. // The configuration manager will transform this structure into a Full // resource descriptor when it is about to store it in the regsitry. // // Note: There must a be a convention to the order of fields of same type, // (defined on a device by device basis) so that the fields can make sense // to a driver (i.e. when multiple memory ranges are necessary). // typedef struct _CM_PARTIAL_RESOURCE_LIST { USHORT Version; USHORT Revision; ULONG Count; CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1]; } CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST; // // A Full Resource Descriptor is what can be found in the registry. // This is what will be returned to a driver when it queries the registry // to get device information; it will be stored under a key in the hardware // description tree. // // Note: There must a be a convention to the order of fields of same type, // (defined on a device by device basis) so that the fields can make sense // to a driver (i.e. when multiple memory ranges are necessary). // typedef struct _CM_FULL_RESOURCE_DESCRIPTOR { INTERFACE_TYPE InterfaceType; // unused for WDM ULONG BusNumber; // unused for WDM CM_PARTIAL_RESOURCE_LIST PartialResourceList; } CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR; // // The Resource list is what will be stored by the drivers into the // resource map via the IO API. // typedef struct _CM_RESOURCE_LIST { ULONG Count; CM_FULL_RESOURCE_DESCRIPTOR List[1]; } CM_RESOURCE_LIST, *PCM_RESOURCE_LIST; #endif // !defined (NT_INCLUDED) #ifdef __cplusplus } // extern "C" #endif