pnpmap.c File Reference

#include "iop.h"
#include "pnpcvrt.h"
#include "pbios.h"

Go to the source code of this file.

Classes
struct	_EXCLUDED_PNPNODE
struct	_CLASSDATA
struct	_CLASS_DESCRIPTIONS_LIST
struct	_BIOS_DEVNODE_INFO
Defines
#define	DebugPrint(X)
#define	MULTIFUNCTION_KEY_NAME   L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter"
#define	ENUMROOT_KEY_NAME   L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\Root"
#define	BIOSINFO_KEY_NAME   L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Biosinfo\\PNPBios"
#define	BIOSINFO_VALUE_NAME   L"DisableNodes"
#define	DECODEINFO_VALUE_NAME   L"FullDecodeChipsetOverride"
#define	INSTANCE_ID_PREFIX   L"PnPBIOS_"
#define	DEFAULT_STRING_SIZE   80
#define	DEFAULT_VALUE_SIZE   80
#define	DEFAULT_DEVICE_DESCRIPTION   L"Unknown device class"
#define	EXCLUSION_ENTRY(a)   { a, sizeof(a) - sizeof(UNICODE_NULL) }
#define	EXCLUDED_DEVICES_COUNT   (sizeof(ExcludedDevices) / sizeof(ExcludedDevices[0]))
#define	EXCLUDE_DISABLED_COUNT   (sizeof(ExcludeIfDisabled) / sizeof(ExcludeIfDisabled[0]))
#define	CLASSLIST_ENTRY(a)   { a, sizeof(a) / sizeof(a[0]) }
#define	CLASSLIST_COUNT   ( sizeof(ClassDescriptionsList) / sizeof(ClassDescriptionsList[0]) )
#define	DECODE_FLAGS
Typedefs
typedef _EXCLUDED_PNPNODE	EXCLUDED_PNPNODE
typedef _EXCLUDED_PNPNODE *	PEXCLUDED_PNPNODE
typedef _CLASSDATA	CLASSDATA
typedef _BIOS_DEVNODE_INFO	BIOS_DEVNODE_INFO
typedef _BIOS_DEVNODE_INFO *	PBIOS_DEVNODE_INFO
Functions
NTSTATUS	PbBiosResourcesToNtResources (IN ULONG BusNumber, IN ULONG SlotNumber, IN OUT PUCHAR *BiosData, OUT PIO_RESOURCE_REQUIREMENTS_LIST *ReturnedList, OUT PULONG ReturnedLength)
VOID	PnPBiosExpandProductId (PUCHAR CompressedId, PWCHAR ProductIDStr)
NTSTATUS	PnPBiosIoResourceListToCmResourceList (IN PIO_RESOURCE_REQUIREMENTS_LIST IoResourceList, OUT PCM_RESOURCE_LIST *CmResourceList, OUT ULONG *CmResourceListSize)
NTSTATUS	PnPBiosExtractCompatibleIDs (IN PUCHAR *DevNodeData, IN ULONG DevNodeDataLength, OUT PWSTR *CompatibleIDs, OUT ULONG *CompatibleIDsLength)
NTSTATUS	PnPBiosTranslateInfo (IN VOID *BiosInfo, IN ULONG BiosInfoLength, OUT PBIOS_DEVNODE_INFO *DevNodeInfoList, OUT ULONG *NumberNodes)
LONG	PnPBiosFindMatchingDevNode (IN PWCHAR MapperName, IN PCM_RESOURCE_LIST ResourceList, IN PBIOS_DEVNODE_INFO DevNodeInfoList, IN ULONG NumberNodes)
NTSTATUS	PnPBiosEliminateDupes (IN PBIOS_DEVNODE_INFO DevNodeInfoList, IN ULONG NumberNodes)
PWCHAR	PnPBiosGetDescription (IN PBIOS_DEVNODE_INFO DevNodeInfoEntry)
NTSTATUS	PnPBiosWriteInfo (IN PBIOS_DEVNODE_INFO DevNodeInfoList, IN ULONG NumberNodes)
VOID	PnPBiosCopyIoDecode (IN HANDLE EnumRootKey, IN PBIOS_DEVNODE_INFO DevNodeInfo)
NTSTATUS	PnPBiosFreeDevNodeInfo (IN PBIOS_DEVNODE_INFO DevNodeInfoList, IN ULONG NumberNodes)
NTSTATUS	PnPBiosCheckForHardwareDisabled (IN PIO_RESOURCE_REQUIREMENTS_LIST IoResourceList, IN OUT PBOOLEAN Disabled)
BOOLEAN	PnPBiosCheckForExclusion (IN PEXCLUDED_PNPNODE ExclusionArray, IN ULONG ExclusionCount, IN PWCHAR PnpDeviceName, IN PWCHAR PnpCompatIds)
NTSTATUS	PnPBiosMapper (VOID)
VOID	PpFilterNtResource (IN PWCHAR PnpDeviceName, PIO_RESOURCE_REQUIREMENTS_LIST ResReqList)
NTSTATUS	ComPortDBAdd (IN HANDLE DeviceParamKey, IN PWSTR PortName)
NTSTATUS	PnPBiosGetBiosInfo (OUT PVOID *BiosInfo, OUT ULONG *BiosInfoLength)
BOOLEAN	PnPBiosIgnoreNode (PWCHAR PnpID, PWCHAR excludeNodes)
VOID	PnPGetDevnodeExcludeList (OUT PKEY_VALUE_FULL_INFORMATION *ExcludeList)
BOOLEAN	PnPCheckFixedIoOverrideDecodes (VOID)
BOOLEAN	PnPBiosCheckForExclusion (IN EXCLUDED_PNPNODE *Exclusions, IN ULONG ExclusionCount, IN PWCHAR PnpDeviceName, IN PWCHAR PnpCompatIds)
NTSTATUS	PnPBiosCopyDeviceParamKey (IN HANDLE EnumRootKey, IN PWCHAR SourcePath, IN PWCHAR DestinationPath)
NTSTATUS	PnPBiosMapper ()
Variables
EXCLUDED_PNPNODE	ExcludedDevices []
EXCLUDED_PNPNODE	ExcludeIfDisabled []
CLASSDATA	Class1Descriptions []
CLASSDATA	Class2Descriptions []
CLASSDATA	Class3Descriptions []
CLASSDATA	Class4Descriptions []
CLASSDATA	Class5Descriptions []
CLASSDATA	Class6Descriptions []
CLASSDATA	Class7Descriptions []
CLASSDATA	Class8Descriptions []
CLASSDATA	Class9Descriptions []
CLASSDATA	Class10Descriptions []
CLASSDATA	Class11Descriptions []
CLASSDATA	Class12Descriptions []
_CLASS_DESCRIPTIONS_LIST	ClassDescriptionsList []

---

Define Documentation

#define BIOSINFO_KEY_NAME   L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Biosinfo\\PNPBios"

Definition at line 86 of file pnpmap.c. Referenced by PnPCheckFixedIoOverrideDecodes(), and PnPGetDevnodeExcludeList().

#define BIOSINFO_VALUE_NAME   L"DisableNodes"

Definition at line 87 of file pnpmap.c. Referenced by PnPGetDevnodeExcludeList().

#define CLASSLIST_COUNT   ( sizeof(ClassDescriptionsList) / sizeof(ClassDescriptionsList[0]) )

Definition at line 255 of file pnpmap.c. Referenced by PnPBiosGetDescription().

#define CLASSLIST_ENTRY (  a   )     { a, sizeof(a) / sizeof(a[0]) }

Definition at line 231 of file pnpmap.c.

#define DebugPrint (  X   )

Definition at line 74 of file pnpmap.c.

#define DECODE_FLAGS

Value: ( CM_RESOURCE_PORT_10_BIT_DECODE | \ CM_RESOURCE_PORT_12_BIT_DECODE | \ CM_RESOURCE_PORT_16_BIT_DECODE | \ CM_RESOURCE_PORT_POSITIVE_DECODE ) Referenced by PnPBiosCopyIoDecode().

#define DECODEINFO_VALUE_NAME   L"FullDecodeChipsetOverride"

Definition at line 88 of file pnpmap.c. Referenced by PnPCheckFixedIoOverrideDecodes().

#define DEFAULT_DEVICE_DESCRIPTION   L"Unknown device class"

Definition at line 95 of file pnpmap.c. Referenced by PnPBiosGetDescription().

#define DEFAULT_STRING_SIZE   80

Definition at line 92 of file pnpmap.c. Referenced by PnPBiosCopyDeviceParamKey(), PnPBiosCopyIoDecode(), PnPBiosEliminateDupes(), PnPBiosGetBiosInfo(), and PnPBiosWriteInfo().

#define DEFAULT_VALUE_SIZE   80

Definition at line 93 of file pnpmap.c. Referenced by PnPBiosCopyDeviceParamKey().

#define ENUMROOT_KEY_NAME   L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\Root"

Definition at line 83 of file pnpmap.c. Referenced by PnPBiosCopyIoDecode(), PnPBiosEliminateDupes(), and PnPBiosWriteInfo().

#define EXCLUDE_DISABLED_COUNT   (sizeof(ExcludeIfDisabled) / sizeof(ExcludeIfDisabled[0]))

Definition at line 124 of file pnpmap.c. Referenced by PnPBiosWriteInfo().

#define EXCLUDED_DEVICES_COUNT   (sizeof(ExcludedDevices) / sizeof(ExcludedDevices[0]))

Definition at line 117 of file pnpmap.c. Referenced by PnPBiosWriteInfo().

#define EXCLUSION_ENTRY (  a   )     { a, sizeof(a) - sizeof(UNICODE_NULL) }

Definition at line 98 of file pnpmap.c.

#define INSTANCE_ID_PREFIX   L"PnPBIOS_"

Definition at line 90 of file pnpmap.c. Referenced by PnPBiosEliminateDupes(), and PnPBiosWriteInfo().

#define MULTIFUNCTION_KEY_NAME   L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter"

Definition at line 82 of file pnpmap.c. Referenced by PnPBiosGetBiosInfo().

---

Typedef Documentation

typedef struct _BIOS_DEVNODE_INFO BIOS_DEVNODE_INFO

typedef struct _CLASSDATA CLASSDATA

typedef struct _EXCLUDED_PNPNODE EXCLUDED_PNPNODE

typedef struct _BIOS_DEVNODE_INFO * PBIOS_DEVNODE_INFO

Referenced by PnPBiosMapper(), and PnPBiosTranslateInfo().

typedef struct _EXCLUDED_PNPNODE * PEXCLUDED_PNPNODE

---

Function Documentation

NTSTATUS ComPortDBAdd (  IN HANDLE  DeviceParamKey, IN PWSTR  PortName )

Referenced by MapperSeedKey(), and PnPBiosCopyDeviceParamKey().

NTSTATUS PbBiosResourcesToNtResources (  IN ULONG  BusNumber, IN ULONG  SlotNumber, IN OUT PUCHAR *  BiosData, OUT PIO_RESOURCE_REQUIREMENTS_LIST *  ReturnedList, OUT PULONG  ReturnedLength )

BOOLEAN PnPBiosCheckForExclusion (  IN EXCLUDED_PNPNODE *  Exclusions, IN ULONG  ExclusionCount, IN PWCHAR  PnpDeviceName, IN PWCHAR  PnpCompatIds )

Definition at line 835 of file pnpmap.c. References FALSE, NULL, and TRUE. Referenced by PnPBiosWriteInfo(). { PWCHAR idPtr; ULONG exclusionIndex; for (exclusionIndex = 0; exclusionIndex < ExclusionCount; exclusionIndex++) { idPtr = PnpDeviceName; if (RtlCompareMemory( idPtr, Exclusions[ exclusionIndex ].Id, Exclusions[ exclusionIndex ].IdLength) != Exclusions[ exclusionIndex ].IdLength ) { idPtr = PnpCompatIds; if (idPtr != NULL) { while (*idPtr != '\0') { if (RtlCompareMemory( idPtr, Exclusions[ exclusionIndex ].Id, Exclusions[ exclusionIndex ].IdLength) == Exclusions[ exclusionIndex ].IdLength ) { break; } idPtr += 9; } if (*idPtr == '\0') { idPtr = NULL; } } } if (idPtr != NULL) { break; } } if (exclusionIndex < ExclusionCount) { return TRUE; } return FALSE; }

BOOLEAN PnPBiosCheckForExclusion (  IN PEXCLUDED_PNPNODE  ExclusionArray, IN ULONG  ExclusionCount, IN PWCHAR  PnpDeviceName, IN PWCHAR  PnpCompatIds )

NTSTATUS PnPBiosCheckForHardwareDisabled (  IN PIO_RESOURCE_REQUIREMENTS_LIST  IoResourceList, IN OUT PBOOLEAN  Disabled )

Definition at line 2852 of file pnpmap.c. References ASSERT, DebugPrint, FALSE, NULL, and TRUE. Referenced by PnPBiosTranslateInfo(). : If this device has been assigned one or more resources, and each resource has a length of zero, then it is hardware disabled. Arguments: IoResourceList - Resource obtained from BIOS that we're about to map to a CmResourceList Disabled - Set to TRUE if the device is deemed to be disabled Return Value: STATUS_SUCCESS if no errors, otherwise the appropriate error. --*/ { BOOLEAN ParsedResource = FALSE; PIO_RESOURCE_DESCRIPTOR ioDescriptor; ULONG descIndex; // // Since this routine is only used to translate the allocated resources // returned by the PnP BIOS, we can assume that there is only 1 alternative // list // ASSERT(IoResourceList->AlternativeLists == 1); ASSERT(Disabled != NULL); *Disabled = FALSE; // // Translate each resource descriptor, currently we only handle ports, // memory, interrupts, and dma. The current implementation of the routine // which converts from ISA PnP Resource data to IO_RESOURCE_REQUIREMENTS // won't generate any other descriptor types given the data returned from // the BIOS. // for (descIndex = 0; descIndex < IoResourceList->List[ 0 ].Count; descIndex++) { ioDescriptor = &IoResourceList->List[ 0 ].Descriptors[ descIndex ]; switch (ioDescriptor->Type) { case CmResourceTypePort: if (ioDescriptor->u.Port.Length) { return STATUS_SUCCESS; } ParsedResource = TRUE; break; case CmResourceTypeInterrupt: if (ioDescriptor->u.Interrupt.MinimumVector != (ULONG)(-1)) { return STATUS_SUCCESS; } ParsedResource = TRUE; break; case CmResourceTypeMemory: if (ioDescriptor->u.Memory.Length) { return STATUS_SUCCESS; } ParsedResource = TRUE; break; case CmResourceTypeDma: if (ioDescriptor->u.Dma.MinimumChannel != (ULONG)(-1)) { return STATUS_SUCCESS; } ParsedResource = TRUE; break; default: DebugPrint( (MAPPER_ERROR, "Unexpected ResourceType (%d) in I/O Descriptor\n", ioDescriptor->Type) ); #if DBG // DbgBreakPoint(); #endif break; } } if (ParsedResource) { // // at least one empty resource, no non-empty resources // *Disabled = TRUE; } return STATUS_SUCCESS; }

NTSTATUS PnPBiosCopyDeviceParamKey (  IN HANDLE  EnumRootKey, IN PWCHAR  SourcePath, IN PWCHAR  DestinationPath )

Definition at line 2089 of file pnpmap.c. References ComPortDBAdd(), DebugPrint, DEFAULT_STRING_SIZE, DEFAULT_VALUE_SIZE, ExAllocatePool, ExFreePool(), IopOpenDeviceParametersSubkey(), IopOpenRegistryKeyEx(), L, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, RtlCompareUnicodeString(), RtlInitUnicodeString(), TRUE, and USHORT. Referenced by PnPBiosWriteInfo(). : Copy the Device Parameters key from the firmware mapper node in DevNodeInfo->Replaces to the BIOS mapper node represented by DevNodeInfo. Arguments: EnumRootKey - Handle to Enum\Root. SourcePath - Instance path of FW Mapper node relative to Enum\Root. DestinationKey - Handle to destination instance key. Return Value: STATUS_SUCCESS if no errors, otherwise the appropriate error. --*/ { NTSTATUS status; UNICODE_STRING sourceInstanceKeyName; HANDLE sourceInstanceKey = NULL; UNICODE_STRING deviceParamKeyName; HANDLE sourceDeviceParamKey = NULL; HANDLE destinationDeviceParamKey = NULL; UNICODE_STRING destinationInstanceKeyName; PKEY_VALUE_FULL_INFORMATION valueFullInfo = NULL; ULONG valueFullInfoLength; ULONG resultLength; UNICODE_STRING valueName; ULONG index; RtlInitUnicodeString( &sourceInstanceKeyName, SourcePath ); status = IopOpenRegistryKeyEx( &sourceInstanceKey, EnumRootKey, &sourceInstanceKeyName, KEY_ALL_ACCESS ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "PnPBiosCopyDeviceParamKey() - Could not open source instance key %S, status = %8.8X\n", SourcePath, status) ); return status; } RtlInitUnicodeString(&deviceParamKeyName, REGSTR_KEY_DEVICEPARAMETERS); status = IopOpenRegistryKeyEx( &sourceDeviceParamKey, sourceInstanceKey, &deviceParamKeyName, KEY_ALL_ACCESS ); if (!NT_SUCCESS(status)) { if (status != STATUS_OBJECT_NAME_NOT_FOUND) { DebugPrint( (MAPPER_ERROR, "PnPBiosCopyDeviceParamKey() - Could not open source device parameter key %S\\%S, status = %8.8X\n", SourcePath, deviceParamKeyName.Buffer, status) ); } goto Cleanup; } RtlInitUnicodeString(&destinationInstanceKeyName, DestinationPath); status = IopOpenDeviceParametersSubkey( &destinationDeviceParamKey, EnumRootKey, &destinationInstanceKeyName, KEY_ALL_ACCESS ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "PnPBiosCopyDeviceParamKey() - Could not open destination device parameter key %S\\%S, status = %8.8X\n", DestinationPath, REGSTR_KEY_DEVICEPARAMETERS, status) ); goto Cleanup; } valueFullInfoLength = sizeof(KEY_VALUE_FULL_INFORMATION) + DEFAULT_STRING_SIZE + DEFAULT_VALUE_SIZE; valueFullInfo = ExAllocatePool(PagedPool, valueFullInfoLength); if (valueFullInfo == NULL) { goto Cleanup; } for (index = 0; ; index++) { status = ZwEnumerateValueKey( sourceDeviceParamKey, index, KeyValueFullInformation, valueFullInfo, valueFullInfoLength, &resultLength ); if (NT_SUCCESS(status)) { UNICODE_STRING sourcePathString; UNICODE_STRING serialPrefixString; UNICODE_STRING portNameString; valueName.Length = (USHORT)valueFullInfo->NameLength; valueName.MaximumLength = valueName.Length; valueName.Buffer = valueFullInfo->Name; RtlInitUnicodeString(&sourcePathString, SourcePath); RtlInitUnicodeString(&serialPrefixString, L"*PNP0501"); if (sourcePathString.Length > serialPrefixString.Length) { sourcePathString.Length = serialPrefixString.Length; } if (RtlCompareUnicodeString(&sourcePathString, &serialPrefixString, TRUE) == 0) { RtlInitUnicodeString(&portNameString, L"PortName"); if (valueName.Length == 16 && RtlCompareUnicodeString(&valueName, &portNameString, TRUE) == 0) { // ComPortDBRemove(SourcePath, &unicodeValue); ComPortDBAdd(destinationDeviceParamKey, (PWSTR)((PUCHAR)valueFullInfo + valueFullInfo->DataOffset)); continue; } } status = ZwSetValueKey( destinationDeviceParamKey, &valueName, valueFullInfo->TitleIndex, valueFullInfo->Type, (PUCHAR)valueFullInfo + valueFullInfo->DataOffset, valueFullInfo->DataLength ); } else { if (status == STATUS_BUFFER_OVERFLOW) { ExFreePool( valueFullInfo ); valueFullInfoLength = resultLength; valueFullInfo = ExAllocatePool(PagedPool, valueFullInfoLength); if (valueFullInfo == NULL) { status = STATUS_NO_MEMORY; } else { index--; continue; } } else if (status != STATUS_NO_MORE_ENTRIES) { DebugPrint( (MAPPER_ERROR, "Could not enumerate under key %S\\%S, status = %8.8X\n", SourcePath, deviceParamKeyName.Buffer, status) ); } else { status = STATUS_SUCCESS; } break; } } Cleanup: if (sourceInstanceKey != NULL) { ZwClose( sourceInstanceKey ); } if (sourceDeviceParamKey != NULL) { ZwClose( sourceDeviceParamKey ); } if (destinationDeviceParamKey != NULL) { ZwClose( destinationDeviceParamKey ); } if (valueFullInfo != NULL) { ExFreePool( valueFullInfo ); } return status; }

VOID PnPBiosCopyIoDecode (  IN HANDLE  EnumRootKey, IN PBIOS_DEVNODE_INFO  DevNodeInfo )

Definition at line 2663 of file pnpmap.c. References ASSERT, DebugPrint, DECODE_FLAGS, DEFAULT_STRING_SIZE, ENUMROOT_KEY_NAME, ExAllocatePool, ExFreePool(), IopCreateRegistryKeyEx(), L, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, RtlInitUnicodeString(), and USHORT. Referenced by PnPBiosWriteInfo(). { HANDLE deviceKey; WCHAR logConfKeyNameStr[DEFAULT_STRING_SIZE]; UNICODE_STRING logConfKeyName; HANDLE logConfKey; UNICODE_STRING valueName; PKEY_VALUE_PARTIAL_INFORMATION valueInfo = NULL; ULONG valueInfoLength; ULONG returnedLength; NTSTATUS status; PCM_PARTIAL_RESOURCE_LIST partialResourceList; PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptor; ULONG index; USHORT flags; if (DevNodeInfo->Replaces == NULL || DevNodeInfo->BootConfig == NULL) { // // If we didn't find a FW Mapper created devnode then there is nothing // to do. // return; } // // Search through the Boot Config and see if the device's I/O ports are // 16 bit decode. // ASSERT(DevNodeInfo->BootConfig->Count == 1); partialResourceList = &DevNodeInfo->BootConfig->List[0].PartialResourceList; partialDescriptor = &partialResourceList->PartialDescriptors[0]; flags = (USHORT)~0; #define DECODE_FLAGS ( CM_RESOURCE_PORT_10_BIT_DECODE | \ CM_RESOURCE_PORT_12_BIT_DECODE | \ CM_RESOURCE_PORT_16_BIT_DECODE | \ CM_RESOURCE_PORT_POSITIVE_DECODE ) for ( index = 0; index < partialResourceList->Count; index++ ) { if (partialDescriptor->Type == CmResourceTypePort) { if (flags == (USHORT)~0) { flags = partialDescriptor->Flags & DECODE_FLAGS; } else { ASSERT(flags == (partialDescriptor->Flags & DECODE_FLAGS)); } } partialDescriptor++; } if (!(flags & (CM_RESOURCE_PORT_16_BIT_DECODE | CM_RESOURCE_PORT_POSITIVE_DECODE))) { return; } swprintf( logConfKeyNameStr, L"%s\\%s", DevNodeInfo->Replaces, REGSTR_KEY_LOGCONF ); RtlInitUnicodeString( &logConfKeyName, logConfKeyNameStr ); status = IopCreateRegistryKeyEx( &logConfKey, EnumRootKey, &logConfKeyName, KEY_ALL_ACCESS, REG_OPTION_NON_VOLATILE, NULL ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "Could not open registry key %S\\%S\\%S, status = %8.8X\n", ENUMROOT_KEY_NAME, DevNodeInfo->Replaces, REGSTR_KEY_LOGCONF, status) ); return; } valueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + DEFAULT_STRING_SIZE; valueInfo = ExAllocatePool(PagedPool, valueInfoLength); if (valueInfo == NULL) { ZwClose( logConfKey ); return; } RtlInitUnicodeString( &valueName, REGSTR_VAL_BOOTCONFIG ); status = ZwQueryValueKey( logConfKey, &valueName, KeyValuePartialInformation, valueInfo, valueInfoLength, &returnedLength); if (!NT_SUCCESS(status)) { if (status == STATUS_BUFFER_TOO_SMALL || status == STATUS_BUFFER_OVERFLOW) { // // The default buffer was too small, free it and reallocate // it to the required size. // ExFreePool( valueInfo ); valueInfoLength = returnedLength; valueInfo = ExAllocatePool( PagedPool, valueInfoLength ); if (valueInfo != NULL) { status = ZwQueryValueKey( logConfKey, &valueName, KeyValuePartialInformation, valueInfo, valueInfoLength, &returnedLength ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "Could not query registry value %S\\%S\\LogConf\\BootConfig, status = %8.8X\n", ENUMROOT_KEY_NAME, DevNodeInfo->Replaces, status) ); ExFreePool( valueInfo ); ZwClose( logConfKey ); return; } } else { DebugPrint( (MAPPER_ERROR, "Could not allocate memory for BootConfig value\n" ) ); ZwClose( logConfKey ); return; } } } partialResourceList = &((PCM_RESOURCE_LIST)valueInfo->Data)->List[0].PartialResourceList; partialDescriptor = &partialResourceList->PartialDescriptors[0]; for ( index = 0; index < partialResourceList->Count; index++ ) { if (partialDescriptor->Type == CmResourceTypePort) { partialDescriptor->Flags &= ~DECODE_FLAGS; partialDescriptor->Flags |= flags; } partialDescriptor++; } status = ZwSetValueKey( logConfKey, &valueName, 0, REG_RESOURCE_LIST, valueInfo->Data, valueInfo->DataLength ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "Could not set registry value %S\\%S\\LogConf\\BootConfig, status = %8.8X\n", ENUMROOT_KEY_NAME, DevNodeInfo->Replaces, status) ); } ExFreePool(valueInfo); ZwClose(logConfKey); }

NTSTATUS PnPBiosEliminateDupes (  IN PBIOS_DEVNODE_INFO  DevNodeInfoList, IN ULONG  NumberNodes )

Definition at line 1725 of file pnpmap.c. References DebugPrint, DEFAULT_STRING_SIZE, ENUMROOT_KEY_NAME, ExAllocatePool, ExFreePool(), Handle, INSTANCE_ID_PREFIX, IopOpenRegistryKeyEx(), L, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, PnPBiosFindMatchingDevNode(), and RtlInitUnicodeString(). Referenced by PnPBiosMapper(). : This routine enumerates the Firmware Mapper generated devices under Enum\Root. Those that match entries in DevNodeInfoList have their registry key name stored in the DevNodeInfoList entry so that the Firmare Mapper instance may be removed later. Arguments: DevNodeInfoList - Array of BIOS_DEVNODE_INFO structures, one for each device reported by the BIOS. NumberNodes - Number of BIOS_DEVNODE_INFO elements pointed to by DevNodeInfoList. Return Value: STATUS_SUCCESS if no errors, otherwise the appropriate error. --*/ { UNICODE_STRING enumRootKeyName, valueName; HANDLE enumRootKey; PKEY_BASIC_INFORMATION deviceBasicInfo = NULL; ULONG deviceBasicInfoLength; UNICODE_STRING deviceKeyName; HANDLE deviceKey = NULL; PKEY_BASIC_INFORMATION instanceBasicInfo = NULL; ULONG instanceBasicInfoLength; WCHAR logConfStr[DEFAULT_STRING_SIZE]; UNICODE_STRING logConfKeyName; HANDLE logConfKey = NULL; PKEY_VALUE_PARTIAL_INFORMATION valueInfo = NULL; ULONG valueInfoLength; ULONG returnedLength; ULONG deviceIndex, instanceIndex; NTSTATUS status = STATUS_UNSUCCESSFUL; RtlInitUnicodeString(&enumRootKeyName, ENUMROOT_KEY_NAME); status = IopOpenRegistryKeyEx( &enumRootKey, NULL, &enumRootKeyName, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "Could not open registry key %S, status = %8.8X\n", ENUMROOT_KEY_NAME, status) ); return STATUS_UNSUCCESSFUL; } deviceBasicInfoLength = sizeof(KEY_BASIC_INFORMATION) + DEFAULT_STRING_SIZE; deviceBasicInfo = ExAllocatePool(PagedPool, deviceBasicInfoLength); instanceBasicInfoLength = sizeof(KEY_BASIC_INFORMATION) + DEFAULT_STRING_SIZE; instanceBasicInfo = ExAllocatePool(PagedPool, instanceBasicInfoLength); valueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + DEFAULT_STRING_SIZE; valueInfo = ExAllocatePool(PagedPool, valueInfoLength); if (deviceBasicInfo != NULL && instanceBasicInfo != NULL && valueInfo != NULL) { for (deviceIndex = 0; ; deviceIndex++) { status = ZwEnumerateKey( enumRootKey, deviceIndex, KeyBasicInformation, deviceBasicInfo, deviceBasicInfoLength, &returnedLength); if (!NT_SUCCESS(status)) { if (status != STATUS_NO_MORE_ENTRIES) { DebugPrint( (MAPPER_ERROR, "Could not enumerate under key %S, status = %8.8X\n", ENUMROOT_KEY_NAME, status) ); } else { status = STATUS_SUCCESS; } break; } if (deviceBasicInfo->Name[0] != '*') { continue; } deviceBasicInfo->Name[ deviceBasicInfo->NameLength / 2 ] = L'\0'; RtlInitUnicodeString(&deviceKeyName, deviceBasicInfo->Name); status = IopOpenRegistryKeyEx( &deviceKey, enumRootKey, &deviceKeyName, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "Could not open registry key %S\\%S, status = %8.8X\n", ENUMROOT_KEY_NAME, deviceBasicInfo->Name, status) ); break; } for (instanceIndex = 0; ; instanceIndex++) { status = ZwEnumerateKey( deviceKey, instanceIndex, KeyBasicInformation, instanceBasicInfo, instanceBasicInfoLength, &returnedLength); if (!NT_SUCCESS(status)) { if (status != STATUS_NO_MORE_ENTRIES) { DebugPrint( (MAPPER_ERROR, "Could not enumerate under key %S\\%S, status = %8.8X\n", ENUMROOT_KEY_NAME, deviceBasicInfo->Name, status) ); } else { status = STATUS_SUCCESS; } break; } if (RtlCompareMemory( instanceBasicInfo->Name, INSTANCE_ID_PREFIX, sizeof(INSTANCE_ID_PREFIX) - sizeof(UNICODE_NULL) ) == (sizeof(INSTANCE_ID_PREFIX) - sizeof(UNICODE_NULL))) { continue; } instanceBasicInfo->Name[ instanceBasicInfo->NameLength / 2 ] = L'\0'; RtlCopyMemory( logConfStr, instanceBasicInfo->Name, instanceBasicInfo->NameLength ); logConfStr[ instanceBasicInfo->NameLength / 2 ] = L'\\'; RtlCopyMemory( &logConfStr[ instanceBasicInfo->NameLength / 2 + 1 ], REGSTR_KEY_LOGCONF, sizeof(REGSTR_KEY_LOGCONF) ); RtlInitUnicodeString( &logConfKeyName, logConfStr ); status = IopOpenRegistryKeyEx( &logConfKey, deviceKey, &logConfKeyName, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "Could not open registry key %S\\%S\\%S, status = %8.8X\n", ENUMROOT_KEY_NAME, deviceBasicInfo->Name, logConfStr, status) ); continue; } RtlInitUnicodeString( &valueName, REGSTR_VAL_BOOTCONFIG ); status = ZwQueryValueKey( logConfKey, &valueName, KeyValuePartialInformation, valueInfo, valueInfoLength, &returnedLength ); if (!NT_SUCCESS(status)) { if (status == STATUS_BUFFER_TOO_SMALL || status == STATUS_BUFFER_OVERFLOW) { ExFreePool( valueInfo ); valueInfoLength = returnedLength; valueInfo = ExAllocatePool( PagedPool, valueInfoLength ); if (valueInfo != NULL) { status = ZwQueryValueKey( logConfKey, &valueName, KeyValuePartialInformation, valueInfo, valueInfoLength, &returnedLength ); } else { DebugPrint( (MAPPER_ERROR, "Error allocating memory for %S\\%S\\LogConf\\BootConfig value\n", ENUMROOT_KEY_NAME, deviceBasicInfo->Name) ); valueInfoLength = 0; status = STATUS_NO_MEMORY; break; } } else { DebugPrint( (MAPPER_ERROR, "Error retrieving %S\\%S\\LogConf\\BootConfig size, status = %8.8X\n", ENUMROOT_KEY_NAME, deviceBasicInfo->Name, status) ); status = STATUS_UNSUCCESSFUL; } } if (NT_SUCCESS( status )) { PCM_RESOURCE_LIST resourceList; LONG matchingIndex; resourceList = (PCM_RESOURCE_LIST)valueInfo->Data; matchingIndex = PnPBiosFindMatchingDevNode( deviceBasicInfo->Name, resourceList, DevNodeInfoList, NumberNodes ); if (matchingIndex != -1) { DevNodeInfoList[ matchingIndex ].Replaces = ExAllocatePool( PagedPool, deviceBasicInfo->NameLength + instanceBasicInfo->NameLength + 2 * sizeof(UNICODE_NULL)); if (DevNodeInfoList[ matchingIndex ].Replaces != NULL) { RtlCopyMemory( DevNodeInfoList[ matchingIndex ].Replaces, deviceBasicInfo->Name, deviceBasicInfo->NameLength ); DevNodeInfoList[ matchingIndex ].Replaces[ deviceBasicInfo->NameLength / 2 ] = '\\'; RtlCopyMemory( &DevNodeInfoList[ matchingIndex ].Replaces[ deviceBasicInfo->NameLength / 2 + 1 ], instanceBasicInfo->Name, instanceBasicInfo->NameLength ); DevNodeInfoList[ matchingIndex ].Replaces[ (deviceBasicInfo->NameLength + instanceBasicInfo->NameLength) / 2 + 1 ] = '\0'; DebugPrint( (MAPPER_INFORMATION, "Match found: %S\\%S%d replaces %S\n", DevNodeInfoList[ matchingIndex ].ProductId, INSTANCE_ID_PREFIX, DevNodeInfoList[ matchingIndex ].Handle, DevNodeInfoList[ matchingIndex ].Replaces) ); } else { DebugPrint( (MAPPER_ERROR, "Error allocating memory for %S\\%S%d\\Replaces\n", DevNodeInfoList[ matchingIndex ].ProductId, INSTANCE_ID_PREFIX, DevNodeInfoList[ matchingIndex ].Handle) ); } } else { DebugPrint( (MAPPER_INFORMATION, "No matching PnP Bios DevNode found for FW Enumerated device %S\\%S\n", deviceBasicInfo->Name, instanceBasicInfo->Name) ); } } else { DebugPrint( (MAPPER_ERROR, "Error retrieving %S\\%S\\%S\\BootConfig, status = %8.8X\n", ENUMROOT_KEY_NAME, deviceBasicInfo->Name, logConfStr, status) ); } ZwClose(logConfKey); logConfKey = NULL; } ZwClose(deviceKey); deviceKey = NULL; } } else { status = STATUS_NO_MEMORY; } if (valueInfo != NULL) { ExFreePool(valueInfo); } if (instanceBasicInfo != NULL) { ExFreePool(instanceBasicInfo); } if (deviceBasicInfo != NULL) { ExFreePool(deviceBasicInfo); } if (logConfKey != NULL) { ZwClose(logConfKey); } if (deviceKey != NULL) { ZwClose(deviceKey); } ZwClose(enumRootKey); return status; }

VOID PnPBiosExpandProductId (  PUCHAR  CompressedId, PWCHAR  ProductIDStr )

Definition at line 687 of file pnpmap.c. References CHAR. Referenced by PnPBiosExtractCompatibleIDs(), and PnPBiosTranslateInfo(). : This function expands a PnP Device ID from the 4 byte compressed form into an 7 character unicode string. The string is then NUL terminated. Arguments: CompressedId - Pointer to the 4 byte compressed Device ID as defined in the PnP Specification. ProductIDStr - Pointer to the 16 byte buffer in which the unicode string version of the ID is placed. Return Value: NONE. --*/ { static CHAR HexDigits[16] = "0123456789ABCDEF"; ProductIDStr[0] = (CompressedId[0] >> 2) + 0x40; ProductIDStr[1] = (((CompressedId[0] & 0x03) << 3) | (CompressedId[1] >> 5)) + 0x40; ProductIDStr[2] = (CompressedId[1] & 0x1f) + 0x40; ProductIDStr[3] = HexDigits[CompressedId[2] >> 4]; ProductIDStr[4] = HexDigits[CompressedId[2] & 0x0F]; ProductIDStr[5] = HexDigits[CompressedId[3] >> 4]; ProductIDStr[6] = HexDigits[CompressedId[3] & 0x0F]; ProductIDStr[7] = 0x00; }

NTSTATUS PnPBiosExtractCompatibleIDs (  IN PUCHAR *  DevNodeData, IN ULONG  DevNodeDataLength, OUT PWSTR *  CompatibleIDs, OUT ULONG *  CompatibleIDsLength )

Definition at line 1026 of file pnpmap.c. References ExAllocatePool, LARGE_RESOURCE_TAG, NULL, PagedPool, PnPBiosExpandProductId(), SMALL_TAG_MASK, SMALL_TAG_SIZE_MASK, TAG_COMPATIBLE_ID, TAG_COMPLETE_END, and USHORT. Referenced by PnPBiosTranslateInfo(). { PWCHAR idPtr; PUCHAR currentPtr, endPtr; UCHAR tagName; ULONG increment; ULONG compatibleCount; endPtr = &(*DevNodeData)[DevNodeDataLength]; compatibleCount = 0; for (currentPtr = *DevNodeData; currentPtr < endPtr; currentPtr += increment) { tagName = *currentPtr; if (tagName == TAG_COMPLETE_END) { break; } // // Determine the size of the BIOS resource descriptor // if (!(tagName & LARGE_RESOURCE_TAG)) { increment = (USHORT)(tagName & SMALL_TAG_SIZE_MASK); increment++; // length of small tag tagName &= SMALL_TAG_MASK; } else { increment = *(USHORT UNALIGNED *)(&currentPtr[1]); increment += 3; // length of large tag } if (tagName == TAG_COMPATIBLE_ID) { compatibleCount++; } } if (compatibleCount == 0) { *CompatibleIDs = NULL; *CompatibleIDsLength = 0; return STATUS_SUCCESS; } *CompatibleIDsLength = (compatibleCount * 9 + 1) * sizeof(WCHAR); *CompatibleIDs = ExAllocatePool(PagedPool, *CompatibleIDsLength); if (*CompatibleIDs == NULL) { *CompatibleIDsLength = 0; return STATUS_NO_MEMORY; } idPtr = *CompatibleIDs; for (currentPtr = *DevNodeData; currentPtr < endPtr; currentPtr += increment) { tagName = *currentPtr; if (tagName == TAG_COMPLETE_END) { break; } // // Determine the size of the BIOS resource descriptor // if (!(tagName & LARGE_RESOURCE_TAG)) { increment = (USHORT)(tagName & SMALL_TAG_SIZE_MASK); increment++; // length of small tag tagName &= SMALL_TAG_MASK; } else { increment = *(USHORT UNALIGNED *)(&currentPtr[1]); increment += 3; // length of large tag } if (tagName == TAG_COMPATIBLE_ID) { *idPtr = '*'; PnPBiosExpandProductId(&currentPtr[1], &idPtr[1]); idPtr += 9; } } *idPtr++ = '\0'; // Extra NUL for REG_MULTI_SZ *CompatibleIDsLength = (ULONG)(idPtr - *CompatibleIDs) * sizeof(WCHAR); return STATUS_SUCCESS; }

LONG PnPBiosFindMatchingDevNode (  IN PWCHAR  MapperName, IN PCM_RESOURCE_LIST  ResourceList, IN PBIOS_DEVNODE_INFO  DevNodeInfoList, IN ULONG  NumberNodes )

Definition at line 1410 of file pnpmap.c. References ASSERT, CHAR, DebugPrint, FALSE, and NULL. Referenced by PnPBiosEliminateDupes(). : Given a list of resources this routine finds an entry in the DevNodeInfoList whose BootConfig resources match. A match is defined as having at least overlapping I/O Ports or Memory Ranges. If ResourceList doesn't include any I/O Ports or Memory Ranges then a match is defined as exactly the same interrupts and/or DMA channels. This routine is used to find PnP BIOS reported devices which match devices created by the Firmware Mapper. Arguments: ResourceList - Pointer to CM_RESOURCE_LIST describing the resources currently used by the device for which a match is being searched. DevNodeInfoList - Array of BIOS_DEVNODE_INFO structures, one for each device reported by the BIOS. NumberNodes - Number of BIOS_DEVNODE_INFO elements pointed to by DevNodeInfoList. Return Value: Index of the entry in DevNodeInfoList whose BootConfig matches the resources listed in ResourceList. If no matching entry is found then -1 is returned. --*/ { PCM_PARTIAL_RESOURCE_LIST sourceList; PCM_PARTIAL_RESOURCE_LIST targetList; PCM_PARTIAL_RESOURCE_DESCRIPTOR sourceDescriptor; PCM_PARTIAL_RESOURCE_DESCRIPTOR targetDescriptor; ULONG nodeIndex, sourceIndex, targetIndex; LONG firstMatch = -1; LONG bestMatch = -1; ULONG numResourcesMatch; ULONG score, possibleScore, bestScore = 0; PWCHAR idPtr; BOOLEAN idsMatch; BOOLEAN bestIdsMatch = FALSE; #if DEBUG_DUP_MATCH CHAR sourceMapping[256]; CHAR targetMapping[256]; #endif // // In order to simplify the problem we assume there is only one list. This // assumption holds true in the BootConfig structures generated by the // current firmware mapper. // ASSERT( ResourceList->Count == 1 ); sourceList = &ResourceList->List[0].PartialResourceList; #if DEBUG_DUP_MATCH // // For debugging purposes we keep track of which resource entries map to // each other. These relationships are stored in a fixed CHAR array, thus // the restriction on the number of descriptors. // ASSERT( sourceList->Count < 255 ); #endif // // Loop through each devnode and try and match it to the source resource // list. // for (nodeIndex = 0; nodeIndex < NumberNodes; nodeIndex++) { if (DevNodeInfoList[ nodeIndex ].BootConfig == NULL) { continue; } // // We found at least one potential match. Let's double check if // the PNP ids also match. We use a lack of ID match to disqualify // entries which don't match at least I/O ports or memory. // idPtr = DevNodeInfoList[ nodeIndex ].ProductId; if (RtlCompareMemory( idPtr, MapperName, 12 ) != 12) { idPtr = DevNodeInfoList[ nodeIndex ].CompatibleIDs; if (idPtr != NULL) { while (*idPtr != '\0') { if (RtlCompareMemory( idPtr, MapperName, 12 ) == 12) { break; } idPtr += 9; } if (*idPtr == '\0') { idPtr = NULL; } } } idsMatch = idPtr != NULL; ASSERT( DevNodeInfoList[ nodeIndex ].BootConfig->Count == 1 ); targetList = &DevNodeInfoList[ nodeIndex ].BootConfig->List[0].PartialResourceList; #if DEBUG_DUP_MATCH RtlFillMemory( sourceMapping, sizeof(sourceMapping), -1 ); RtlFillMemory( targetMapping, sizeof(targetMapping), -1 ); #endif numResourcesMatch = 0; possibleScore = 0; score = 0; // // Loop through each source descriptor (resource) and try and match it // to one of this devnode's descriptors. // for (sourceIndex = 0; sourceIndex < sourceList->Count; sourceIndex++) { sourceDescriptor = &sourceList->PartialDescriptors[sourceIndex]; // // We are recalculating the possible score unnecessarily each time // we process a devnode. We might save a small amount of time by // looping through the source descriptors once at the beginning but // its not clear it would make all that much difference given the // few devices reported by the BIOS. // switch (sourceDescriptor->Type) { case CmResourceTypePort: possibleScore += 0x1100; break; case CmResourceTypeInterrupt: possibleScore += 0x0001; break; case CmResourceTypeMemory: possibleScore += 0x1100; break; case CmResourceTypeDma: possibleScore += 0x0010; break; default: continue; } // // Try to find a resource in the target devnode which matches the // current source resource. // for (targetIndex = 0; targetIndex < targetList->Count; targetIndex++) { targetDescriptor = &targetList->PartialDescriptors[targetIndex]; if (sourceDescriptor->Type == targetDescriptor->Type) { switch (sourceDescriptor->Type) { case CmResourceTypePort: if ((sourceDescriptor->u.Port.Start.LowPart + sourceDescriptor->u.Port.Length) <= targetDescriptor->u.Port.Start.LowPart || (targetDescriptor->u.Port.Start.LowPart + targetDescriptor->u.Port.Length) <= sourceDescriptor->u.Port.Start.LowPart) { continue; } if (sourceDescriptor->u.Port.Start.LowPart == targetDescriptor->u.Port.Start.LowPart && sourceDescriptor->u.Port.Length == targetDescriptor->u.Port.Length) { score += 0x1100; } else { DebugPrint( (MAPPER_INFORMATION, "Overlapping port resources, source = %4.4X-%4.4X, target = %4.4X-%4.4X\n", sourceDescriptor->u.Port.Start.LowPart, sourceDescriptor->u.Port.Start.LowPart + sourceDescriptor->u.Port.Length - 1, targetDescriptor->u.Port.Start.LowPart, targetDescriptor->u.Port.Start.LowPart + targetDescriptor->u.Port.Length - 1) ); score += 0x1000; } break; case CmResourceTypeInterrupt: if (sourceDescriptor->u.Interrupt.Level != targetDescriptor->u.Interrupt.Level) { continue; } score += 0x0001; break; case CmResourceTypeMemory: if ((sourceDescriptor->u.Memory.Start.LowPart + sourceDescriptor->u.Memory.Length) <= targetDescriptor->u.Memory.Start.LowPart || (targetDescriptor->u.Memory.Start.LowPart + targetDescriptor->u.Memory.Length) <= sourceDescriptor->u.Memory.Start.LowPart) { continue; } if (sourceDescriptor->u.Memory.Start.LowPart == targetDescriptor->u.Memory.Start.LowPart && sourceDescriptor->u.Memory.Length == targetDescriptor->u.Memory.Length) { score += 0x1100; } else { score += 0x1000; } break; case CmResourceTypeDma: if (sourceDescriptor->u.Dma.Channel != targetDescriptor->u.Dma.Channel) { continue; } score += 0x0010; break; } break; } } if (targetIndex < targetList->Count) { #if DEBUG_DUP_MATCH sourceMapping[sourceIndex] = (CHAR)targetIndex; targetMapping[targetIndex] = (CHAR)sourceIndex; #endif numResourcesMatch++; } } if (numResourcesMatch != 0) { if (firstMatch == -1) { firstMatch = nodeIndex; } if ((score > bestScore) || (score == bestScore && !bestIdsMatch && idsMatch)) { bestScore = score; bestMatch = nodeIndex; bestIdsMatch = idsMatch; } } } if (bestMatch != -1) { if (bestScore == possibleScore) { DebugPrint( (MAPPER_INFORMATION, "Perfect match, score = %4.4X, possible = %4.4X, index = %d\n", bestScore, possibleScore, bestMatch) ); if (possibleScore < 0x1000 && !bestIdsMatch) { bestMatch = -1; } } else if (possibleScore > 0x1000 && bestScore >= 0x1000) { DebugPrint( (MAPPER_INFORMATION, "Best match is close enough, score = %4.4X, possible = %4.4X, index = %d\n", bestScore, possibleScore, bestMatch) ); } else { DebugPrint( (MAPPER_INFORMATION, "Best match is less than threshold, score = %4.4X, possible = %4.4X, index = %d\n", bestScore, possibleScore, bestMatch) ); bestMatch = -1; } } return bestMatch; }

NTSTATUS PnPBiosFreeDevNodeInfo (  IN PBIOS_DEVNODE_INFO  DevNodeInfoList, IN ULONG  NumberNodes )

Definition at line 2956 of file pnpmap.c. References ExFreePool(), and NULL. Referenced by PnPBiosMapper(). : Free the dynamically allocated DevNodeInfoList as well as any dynamically allocated dependent structures. Arguments: DevNodeInfoList - Array of BIOS_DEVNODE_INFO structures, one for each device reported by the BIOS. NumberNodes - Number of BIOS_DEVNODE_INFO elements pointed to by DevNodeInfoList. Return Value: STATUS_SUCCESS if no errors, otherwise the appropriate error. --*/ { ULONG nodeIndex; for (nodeIndex = 0; nodeIndex < NumberNodes; nodeIndex++) { if (DevNodeInfoList[nodeIndex].Replaces != NULL) { ExFreePool( DevNodeInfoList[nodeIndex].Replaces ); } if (DevNodeInfoList[nodeIndex].CompatibleIDs != NULL) { ExFreePool( DevNodeInfoList[nodeIndex].CompatibleIDs ); } if (DevNodeInfoList[nodeIndex].BootConfig != NULL) { ExFreePool( DevNodeInfoList[nodeIndex].BootConfig ); } if (DevNodeInfoList[nodeIndex].BasicConfig != NULL) { ExFreePool( DevNodeInfoList[nodeIndex].BasicConfig ); } } ExFreePool( DevNodeInfoList ); return STATUS_SUCCESS; }

NTSTATUS PnPBiosGetBiosInfo (  OUT PVOID *  BiosInfo, OUT ULONG *  BiosInfoLength )

Definition at line 399 of file pnpmap.c. References ASSERT, DebugPrint, DEFAULT_STRING_SIZE, ExAllocatePool, ExFreePool(), IopOpenRegistryKeyEx(), L, MULTIFUNCTION_KEY_NAME, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, and RtlInitUnicodeString(). Referenced by PnPBiosMapper(). : This function retrieves the PnP BIOS info accumulated by NTDETECT.COM and placed in the registry. Arguments: BiosInfo - Set to a dynamically allocated block of information retrieved from the PnP BIOS by NTDETECT. This block should be freed using ExFreePool. The contents of the block are the PnP BIOS Installation Check Structure followed by the DevNode Structures reported by the BIOS. The detailed format is documented in the PnP BIOS spec. BiosInfoLength - Length of the block whose address is stored in BiosInfo. Return Value: STATUS_SUCCESS if no errors, otherwise the appropriate error. --*/ { UNICODE_STRING multifunctionKeyName, biosKeyName, valueName; HANDLE multifunctionKey = NULL, biosKey = NULL; PKEY_BASIC_INFORMATION keyBasicInfo = NULL; ULONG keyBasicInfoLength; PKEY_VALUE_PARTIAL_INFORMATION valueInfo = NULL; ULONG valueInfoLength; ULONG returnedLength; PCM_FULL_RESOURCE_DESCRIPTOR biosValue; ULONG index; NTSTATUS status = STATUS_UNSUCCESSFUL; // // The PnP BIOS info is written to one of the subkeys under // MULTIFUNCTION_KEY_NAME. The appropriate key is determined by // enumerating the subkeys and using the first one which has a value named // "Identifier" that is "PNP BIOS". // RtlInitUnicodeString(&multifunctionKeyName, MULTIFUNCTION_KEY_NAME); status = IopOpenRegistryKeyEx( &multifunctionKey, NULL, &multifunctionKeyName, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "Could not open %S, status = %8.8X\n", MULTIFUNCTION_KEY_NAME, status) ); return STATUS_UNSUCCESSFUL; } // // Allocate memory for key names returned from ZwEnumerateKey and values // returned from ZwQueryValueKey. // keyBasicInfoLength = sizeof(KEY_BASIC_INFORMATION) + DEFAULT_STRING_SIZE; keyBasicInfo = ExAllocatePool(PagedPool, keyBasicInfoLength + sizeof(UNICODE_NULL)); if (keyBasicInfo == NULL) { ZwClose( multifunctionKey ); return STATUS_NO_MEMORY; } valueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + DEFAULT_STRING_SIZE; valueInfo = ExAllocatePool(PagedPool, valueInfoLength); if (valueInfo == NULL) { ExFreePool( keyBasicInfo ); ZwClose( multifunctionKey ); return STATUS_NO_MEMORY; } // // Enumerate each key under HKLM\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter // to locate the one representing the PnP BIOS information. // for (index = 0; ; index++) { status = ZwEnumerateKey( multifunctionKey, // handle of key to enumerate index, // index of subkey to enumerate KeyBasicInformation, keyBasicInfo, keyBasicInfoLength, &returnedLength); if (!NT_SUCCESS(status)) { if (status != STATUS_NO_MORE_ENTRIES) { DebugPrint( (MAPPER_ERROR, "Could not enumerate under key %S, status = %8.8X\n", MULTIFUNCTION_KEY_NAME, status) ); } break; } // // We found a subkey, NUL terminate the name and open the subkey. // keyBasicInfo->Name[ keyBasicInfo->NameLength / 2 ] = L'\0'; RtlInitUnicodeString(&biosKeyName, keyBasicInfo->Name); status = IopOpenRegistryKeyEx( &biosKey, multifunctionKey, &biosKeyName, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint( (MAPPER_ERROR, "Could not open registry key %S\\%S, status = %8.8X\n", MULTIFUNCTION_KEY_NAME, keyBasicInfo->Name, status) ); break; } // // Now we need to check the Identifier value in the subkey to see if // it is PNP BIOS. // RtlInitUnicodeString(&valueName, L"Identifier"); status = ZwQueryValueKey( biosKey, &valueName, KeyValuePartialInformation, valueInfo, valueInfoLength, &returnedLength); // lets see if its the PNP BIOS identifier if (NT_SUCCESS(status)) { if (wcscmp((PWSTR)valueInfo->Data, L"PNP BIOS") == 0) { // // We found the PnP BIOS subkey, retrieve the BIOS info which // is stored in the "Configuration Data" value. // // We'll start off with our default value buffer and increase // its size if necessary. // RtlInitUnicodeString(&valueName, L"Configuration Data"); status = ZwQueryValueKey( biosKey, &valueName, KeyValuePartialInformation, valueInfo, valueInfoLength, &returnedLength); if (!NT_SUCCESS(status)) { if (status == STATUS_BUFFER_TOO_SMALL || status == STATUS_BUFFER_OVERFLOW) { // // The default buffer was too small, free it and reallocate // it to the required size. // ExFreePool( valueInfo ); valueInfoLength = returnedLength; valueInfo = ExAllocatePool( PagedPool, valueInfoLength ); if (valueInfo != NULL) { status = ZwQueryValueKey( biosKey, &valueName, KeyValuePartialInformation, valueInfo, valueInfoLength, &returnedLength ); } else { status = STATUS_NO_MEMORY; } } } if (NT_SUCCESS(status)) { // // We now have the PnP BIOS data but it is buried inside // the resource structures. Do some consistency checks and // then extract it into its own buffer. // ASSERT(valueInfo->Type == REG_FULL_RESOURCE_DESCRIPTOR); biosValue = (PCM_FULL_RESOURCE_DESCRIPTOR)valueInfo->Data; // // BUGBUG - The WMI folks added another list so we should // search for the PnPBIOS one, but for now the BIOS one is // always first. // //ASSERT(biosValue->PartialResourceList.Count == 1); *BiosInfoLength = biosValue->PartialResourceList.PartialDescriptors[0].u.DeviceSpecificData.DataSize; *BiosInfo = ExAllocatePool(PagedPool, *BiosInfoLength); if (*BiosInfo != NULL) { RtlCopyMemory( *BiosInfo, &biosValue->PartialResourceList.PartialDescriptors[1], *BiosInfoLength ); status = STATUS_SUCCESS; } else { *BiosInfoLength = 0; status = STATUS_NO_MEMORY; } } else { DebugPrint( (MAPPER_ERROR, "Error retrieving %S\\%S\\Configuration Data, status = %8.8X\n", MULTIFUNCTION_KEY_NAME, keyBasicInfo->Name, status) ); } // // We found the PnP BIOS entry, so close the key handle and // return. // ZwClose(biosKey); break; } } // // That wasn't it so close this handle and try the next subkey. // ZwClose(biosKey); } // // Cleanup the dynamically allocated temporary buffers. // if (valueInfo != NULL) { ExFreePool(valueInfo); } if (keyBasicInfo != NULL) { ExFreePool(keyBasicInfo); } ZwClose(multifunctionKey); return status; }

PWCHAR PnPBiosGetDescription (  IN PBIOS_DEVNODE_INFO  DevNodeInfoEntry  )

Definition at line 2053 of file pnpmap.c. References ClassDescriptionsList, CLASSLIST_COUNT, Count, DEFAULT_DEVICE_DESCRIPTION, _CLASSDATA::Description, and _CLASSDATA::Value. Referenced by PnPBiosWriteInfo(). { ULONG class, subClass; LONG index; CLASSDATA *classDescriptions; LONG descriptionCount; class = DevNodeInfoEntry->TypeCode[0]; subClass = (DevNodeInfoEntry->TypeCode[1] << 8) | DevNodeInfoEntry->TypeCode[2]; if (class > 0 && class < CLASSLIST_COUNT) { classDescriptions = ClassDescriptionsList[ class ].Descriptions; descriptionCount = ClassDescriptionsList[ class ].Count; // // The last description entry is the default so there is no use // comparing it, if we get that far just use it. // for (index = 0; index < (descriptionCount - 1); index++) { if (subClass == classDescriptions[ index ].Value) { break; } } return classDescriptions[ index ].Description; } return DEFAULT_DEVICE_DESCRIPTION; }

BOOLEAN PnPBiosIgnoreNode (  PWCHAR  PnpID, PWCHAR  excludeNodes )

Definition at line 726 of file pnpmap.c. References ASSERT, FALSE, and TRUE. Referenced by PnPBiosWriteInfo(). { BOOLEAN bRet=FALSE; ULONG keyLen; PWCHAR pTmp; ASSERT (excludeNodes); // //excludeNodes is multi-sz, so walk through each one and check it. // pTmp=excludeNodes; while (*pTmp != '\0') { keyLen = wcslen (pTmp); if (RtlCompareMemory (PnpID,pTmp,keyLen*sizeof (WCHAR)) == keyLen*sizeof (WCHAR)) { bRet=TRUE; break; } pTmp=pTmp+keyLen+1; } return bRet; }

NTSTATUS PnPBiosIoResourceListToCmResourceList (  IN PIO_RESOURCE_REQUIREMENTS_LIST  IoResourceList, OUT PCM_RESOURCE_LIST *  CmResourceList, OUT ULONG *  CmResourceListSize )

Definition at line 890 of file pnpmap.c. References ASSERT, DebugPrint, ExAllocatePool, NULL, and PagedPool. Referenced by PnPBiosTranslateInfo(). : Converts an IO_RESOURCE_REQUIREMENTS_LIST into a CM_RESOURCE_LIST. This routine is used to convert the list of resources currently being used by a device into a form suitable for writing to the BootConfig registry value. Arguments: IoResourceList - Pointer to the input list. CmResourceList - Pointer to a PCM_RESOURCE_LIST which is set to the dynamically allocated and filled in using the data from IoResourceList. CmResourceListSize - Pointer to a variable which is set to the size in bytes of the dynamically allocated *CmResourceList. Return Value: STATUS_SUCCESS if no errors, otherwise the appropriate error. --*/ { PCM_PARTIAL_RESOURCE_LIST partialList; PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptor; PIO_RESOURCE_DESCRIPTOR ioDescriptor; ULONG descIndex; // // Since this routine is only used to translate the allocated resources // returned by the PnP BIOS, we can assume that there is only 1 alternative // list // ASSERT(IoResourceList->AlternativeLists == 1); // // Calculate the size of the translated list and allocate memory for it. // *CmResourceListSize = sizeof(CM_RESOURCE_LIST) + (IoResourceList->AlternativeLists - 1) * sizeof(CM_FULL_RESOURCE_DESCRIPTOR) + (IoResourceList->List[0].Count - 1) * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR); *CmResourceList = ExAllocatePool( PagedPool, *CmResourceListSize ); if (*CmResourceList == NULL) { *CmResourceListSize = 0; return STATUS_NO_MEMORY; } // // Copy the header info from the requirements list to the resource list. // (*CmResourceList)->Count = 1; (*CmResourceList)->List[ 0 ].InterfaceType = IoResourceList->InterfaceType; (*CmResourceList)->List[ 0 ].BusNumber = IoResourceList->BusNumber; partialList = &(*CmResourceList)->List[ 0 ].PartialResourceList; partialList->Version = IoResourceList->List[ 0 ].Version; partialList->Revision = IoResourceList->List[ 0 ].Revision; partialList->Count = 0; // // Translate each resource descriptor, currently we only handle ports, // memory, interrupts, and dma. The current implementation of the routine // which converts from ISA PnP Resource data to IO_RESOURCE_REQUIREMENTS // won't generate any other descriptor types given the data returned from // the BIOS. // partialDescriptor = &partialList->PartialDescriptors[ 0 ]; for (descIndex = 0; descIndex < IoResourceList->List[ 0 ].Count; descIndex++) { ioDescriptor = &IoResourceList->List[ 0 ].Descriptors[ descIndex ]; switch (ioDescriptor->Type) { case CmResourceTypePort: partialDescriptor->u.Port.Start = ioDescriptor->u.Port.MinimumAddress; partialDescriptor->u.Port.Length = ioDescriptor->u.Port.Length; break; case CmResourceTypeInterrupt: if (ioDescriptor->u.Interrupt.MinimumVector == (ULONG)(IsNEC_98 ? 7 : 2) ) { *CmResourceListSize -= sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR); continue; } partialDescriptor->u.Interrupt.Level = ioDescriptor->u.Interrupt.MinimumVector; partialDescriptor->u.Interrupt.Vector = ioDescriptor->u.Interrupt.MinimumVector; partialDescriptor->u.Interrupt.Affinity = ~0; break; case CmResourceTypeMemory: partialDescriptor->u.Memory.Start = ioDescriptor->u.Memory.MinimumAddress; partialDescriptor->u.Memory.Length = ioDescriptor->u.Memory.Length; break; case CmResourceTypeDma: partialDescriptor->u.Dma.Channel = ioDescriptor->u.Dma.MinimumChannel; partialDescriptor->u.Dma.Port = 0; partialDescriptor->u.Dma.Reserved1 = 0; break; default: DebugPrint( (MAPPER_ERROR, "Unexpected ResourceType (%d) in I/O Descriptor\n", ioDescriptor->Type) ); #if DBG // DbgBreakPoint(); #endif break; } partialDescriptor->Type = ioDescriptor->Type; partialDescriptor->ShareDisposition = ioDescriptor->ShareDisposition; partialDescriptor->Flags = ioDescriptor->Flags; partialDescriptor++; partialList->Count++; } return STATUS_SUCCESS; }

NTSTATUS PnPBiosMapper (   )

Definition at line 3008 of file pnpmap.c. References ExFreePool(), NT_SUCCESS, NTSTATUS(), PBIOS_DEVNODE_INFO, PnPBiosEliminateDupes(), PnPBiosFreeDevNodeInfo(), PnPBiosGetBiosInfo(), PnPBiosTranslateInfo(), and PnPBiosWriteInfo(). Referenced by IopInitializePlugPlayServices(). : Map the information provided from the PnP BIOS and stored in the registry by NTDETECT into root enumerated devices. Arguments: NONE Return Value: STATUS_SUCCESS if no errors, otherwise the appropriate error. --*/ { PCM_RESOURCE_LIST biosInfo; ULONG length; NTSTATUS status; PBIOS_DEVNODE_INFO devNodeInfoList; ULONG numberNodes; status = PnPBiosGetBiosInfo( &biosInfo, &length ); if (!NT_SUCCESS( status )) { return status; } status = PnPBiosTranslateInfo( biosInfo, length, &devNodeInfoList, &numberNodes ); ExFreePool( biosInfo ); if (!NT_SUCCESS( status )) { return status; } status = PnPBiosEliminateDupes( devNodeInfoList, numberNodes ); if (NT_SUCCESS( status )) { status = PnPBiosWriteInfo( devNodeInfoList, numberNodes ); } PnPBiosFreeDevNodeInfo( devNodeInfoList, numberNodes ); return status; }

NTSTATUS PnPBiosMapper (  VOID   )

NTSTATUS PnPBiosTranslateInfo (  IN VOID *  BiosInfo, IN ULONG  BiosInfoLength, OUT PBIOS_DEVNODE_INFO *  DevNodeInfoList, OUT ULONG *  NumberNodes )

Definition at line 1126 of file pnpmap.c. References ASSERT, _BIOS_DEVNODE_INFO::Attributes, _BIOS_DEVNODE_INFO::BasicConfig, _BIOS_DEVNODE_INFO::BootConfig, _BIOS_DEVNODE_INFO::CompatibleIDs, DebugPrint, ExAllocatePool, ExFreePool(), FALSE, _BIOS_DEVNODE_INFO::FirmwareDisabled, Handle, _BIOS_DEVNODE_INFO::Handle, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, PBIOS_DEVNODE_INFO, PnPBiosCheckForHardwareDisabled(), PnPBiosExpandProductId(), PnPBiosExtractCompatibleIDs(), PnPBiosIoResourceListToCmResourceList(), PnPCheckFixedIoOverrideDecodes(), PpBiosResourcesToNtResources(), PPCONVERTFLAG_FORCE_FIXED_IO_16BIT_DECODE, PPCONVERTFLAG_SET_RESTART_LCPRI, PpFilterNtResource(), _BIOS_DEVNODE_INFO::ProductId, _BIOS_DEVNODE_INFO::Replaces, and _BIOS_DEVNODE_INFO::TypeCode. Referenced by PnPBiosMapper(). : Translates the devnode info retrieved from the BIOS. Arguments: BiosInfo - The PnP BIOS Installation Check Structure followed by the DevNode Structures reported by the BIOS. The detailed format is documented in the PnP BIOS spec. BiosInfoLength - Length in bytes of the block whose address is stored in BiosInfo. DevNodeInfoList - Dynamically allocated array of BIOS_DEVNODE_INFO structures, one for each device reported by the BIOS. The information supplied by the BIOS: device ID, type, current resources, and supported configurations is converted into a more useful format. For example the current resource allocation is converted from ISA PnP descriptors into an IO_RESOURCE_REQUIREMENTS_LIST and then into a CM_RESOURCE_LIST for storing into the BootConfig registry value. NumberNodes - Number of BIOS_DEVNODE_INFO elements pointed to by DevNodeInfoList. Return Value: STATUS_SUCCESS if no errors, otherwise the appropriate error. --*/ { PCM_PNP_BIOS_INSTALLATION_CHECK biosInstallCheck; PCM_PNP_BIOS_DEVICE_NODE devNodeHeader; PBIOS_DEVNODE_INFO devNodeInfo; PKEY_VALUE_FULL_INFORMATION excludeList=NULL; PIO_RESOURCE_REQUIREMENTS_LIST tempResReqList; PUCHAR currentPtr; LONG lengthRemaining; LONG remainingNodeLength; ULONG numNodes; ULONG nodeIndex; PUCHAR configPtr; ULONG configListLength; NTSTATUS status; ULONG convertFlags = 0; // // Make sure the data is at least large enough to hold the BIOS Installation // Check structure and check that the PnP signature is correct. // if (BiosInfoLength < sizeof(CM_PNP_BIOS_INSTALLATION_CHECK)) { DebugPrint( (MAPPER_ERROR, "BiosInfoLength (%d) is smaller than sizeof(PNPBIOS_INSTALLATION_CHECK) (%d)\n", BiosInfoLength, sizeof(CM_PNP_BIOS_INSTALLATION_CHECK)) ); return STATUS_UNSUCCESSFUL; } biosInstallCheck = (PCM_PNP_BIOS_INSTALLATION_CHECK)BiosInfo; if (biosInstallCheck->Signature[0] != '$' || biosInstallCheck->Signature[1] != 'P' || biosInstallCheck->Signature[2] != 'n' || biosInstallCheck->Signature[3] != 'P') { return STATUS_UNSUCCESSFUL; } // // First scan the data and count the devnodes to determine the size of our // allocated data structures. // currentPtr = (PUCHAR)BiosInfo + biosInstallCheck->Length; lengthRemaining = BiosInfoLength - biosInstallCheck->Length; for (numNodes = 0; lengthRemaining > sizeof(CM_PNP_BIOS_DEVICE_NODE); numNodes++) { devNodeHeader = (PCM_PNP_BIOS_DEVICE_NODE)currentPtr; if (devNodeHeader->Size > lengthRemaining) { DebugPrint( (MAPPER_ERROR, "Node # %d, invalid size (%d), length remaining (%d)\n", devNodeHeader->Node, devNodeHeader->Size, lengthRemaining) ); return STATUS_UNSUCCESSFUL; } currentPtr += devNodeHeader->Size; lengthRemaining -= devNodeHeader->Size; } // // Allocate the list of translated devnodes. // devNodeInfo = ExAllocatePool( PagedPool, numNodes * sizeof(BIOS_DEVNODE_INFO) ); if (devNodeInfo == NULL) { return STATUS_NO_MEMORY; } // // Should we force all fixed IO decodes to 16bit? // if (PnPCheckFixedIoOverrideDecodes()) { convertFlags |= PPCONVERTFLAG_FORCE_FIXED_IO_16BIT_DECODE; } // // Now scan the data translating the info for each devnode into an entry in // our devNodeInfo array. // currentPtr = (PUCHAR)BiosInfo + biosInstallCheck->Length; lengthRemaining = BiosInfoLength - biosInstallCheck->Length; for (nodeIndex = 0; nodeIndex < numNodes; nodeIndex++) { devNodeHeader = (PCM_PNP_BIOS_DEVICE_NODE)currentPtr; if (devNodeHeader->Size > lengthRemaining) { DebugPrint( (MAPPER_ERROR, "Node # %d, invalid size (%d), length remaining (%d)\n", devNodeHeader->Node, devNodeHeader->Size, lengthRemaining) ); break; } // // We use the Product ID field as the DeviceID key name. So we insert // an initial asterisk so we don't have to copy and mangle it later. // devNodeInfo[nodeIndex].ProductId[0] = '*'; PnPBiosExpandProductId((PUCHAR)&devNodeHeader->ProductId, &devNodeInfo[nodeIndex].ProductId[1]); devNodeInfo[nodeIndex].ProductId[9] = '\0'; // Extra NUL for REG_MULTI_SZ // // The handle is used as part of the Instance ID devNodeInfo[nodeIndex].Handle = devNodeHeader->Node; // // The type code and attributes aren't currently used but are copied // for completeness. // RtlCopyMemory( &devNodeInfo[nodeIndex].TypeCode, devNodeHeader->DeviceType, sizeof(devNodeInfo[nodeIndex].TypeCode) ); devNodeInfo[nodeIndex].Attributes = devNodeHeader->DeviceAttributes; // // Replaces will eventually be set to the path of the Firmware // Enumerated devnode which duplicates this one (if a duplicate exists). // devNodeInfo[nodeIndex].Replaces = NULL; // // CompatibleIDs will be set to the list of compatible IDs. // devNodeInfo[nodeIndex].CompatibleIDs = NULL; // // Convert the allocated resources from ISA PnP resource descriptor // format to an IO_RESOURCE_REQUIREMENTS_LIST. // configPtr = currentPtr + sizeof(*devNodeHeader); remainingNodeLength = devNodeHeader->Size - sizeof(*devNodeHeader); devNodeInfo[nodeIndex].BootConfig = NULL; devNodeInfo[nodeIndex].FirmwareDisabled = FALSE; status = PpBiosResourcesToNtResources( 0, /* BusNumber */ 0, /* SlotNumber */ &configPtr, /* BiosData */ convertFlags, /* ConvertFlags */ &tempResReqList, /* ReturnedList */ &configListLength); /* ReturnedLength */ remainingNodeLength = devNodeHeader->Size - (LONG)(configPtr - (PUCHAR)devNodeHeader); if (NT_SUCCESS( status )) { if (tempResReqList != NULL) { PpFilterNtResource ( devNodeInfo[nodeIndex].ProductId, tempResReqList ); // // Now we need to convert from a IO_RESOURCE_REQUIREMENTS_LIST to a // CM_RESOURCE_LIST. // status = PnPBiosIoResourceListToCmResourceList( tempResReqList, &devNodeInfo[nodeIndex].BootConfig, &devNodeInfo[nodeIndex].BootConfigLength ); status = PnPBiosCheckForHardwareDisabled(tempResReqList,&devNodeInfo[nodeIndex].FirmwareDisabled); ExFreePool( tempResReqList ); } } else { DebugPrint( (MAPPER_ERROR, "Error converting allocated resources for devnode # %d, status = %8.8X\n", devNodeInfo[nodeIndex].Handle, status) ); } // // Convert the supported resource configurations from ISA PnP resource // descriptor format to an IO_RESOURCE_REQUIREMENTS_LIST. // status = PpBiosResourcesToNtResources( 0, /* BusNumber */ 0, /* SlotNumber */ &configPtr, /* BiosData */ convertFlags | PPCONVERTFLAG_SET_RESTART_LCPRI, /* ConvertFlags */ &devNodeInfo[nodeIndex].BasicConfig, /* ReturnedList */ &devNodeInfo[nodeIndex].BasicConfigLength ); /* ReturnedLength */ remainingNodeLength = devNodeHeader->Size - (LONG)(configPtr - (PUCHAR)devNodeHeader); if (!NT_SUCCESS( status )) { devNodeInfo[nodeIndex].BasicConfig = NULL; DebugPrint( (MAPPER_ERROR, "Error converting allowed resources for devnode # %d, status = %8.8X\n", devNodeInfo[nodeIndex].Handle, status) ); } else { PpFilterNtResource ( devNodeInfo[nodeIndex].ProductId, devNodeInfo[nodeIndex].BasicConfig ); } // // Convert the list of compatible IDs if present // ASSERT(remainingNodeLength >= 0); status = PnPBiosExtractCompatibleIDs( &configPtr, // BiosData (ULONG)remainingNodeLength, &devNodeInfo[nodeIndex].CompatibleIDs, &devNodeInfo[nodeIndex].CompatibleIDsLength ); currentPtr += devNodeHeader->Size; lengthRemaining -= devNodeHeader->Size; } *DevNodeInfoList = devNodeInfo; *NumberNodes = numNodes; return STATUS_SUCCESS; }

NTSTATUS PnPBiosWriteInfo (  IN PBIOS_DEVNODE_INFO  DevNodeInfoList, IN ULONG  NumberNodes )

Definition at line 2289 of file pnpmap.c. References DebugPrint, DEFAULT_STRING_SIZE, ENUMROOT_KEY_NAME, EXCLUDE_DISABLED_COUNT, EXCLUDED_DEVICES_COUNT, ExcludedDevices, ExcludeIfDisabled, ExFreePool(), Handle, INSTANCE_ID_PREFIX, IopCreateRegistryKeyEx(), IopDeleteKeyRecursive(), IopOpenRegistryKeyEx(), L, NT_SUCCESS, NTSTATUS(), NULL, PnPBiosCheckForExclusion(), PnPBiosCopyDeviceParamKey(), PnPBiosCopyIoDecode(), PnPBiosGetDescription(), PnPBiosIgnoreNode(), PnPGetDevnodeExcludeList(), and RtlInitUnicodeString(). Referenced by PnPBiosMapper(). 02295 : 02296 02297 Creates an entry under Enum\Root for each DevNodeInfoList element. Also 02298 removes any duplicate entries which were created by the Firmware Mapper. 02299 02300 Note: Currently entries for the Keyboard, Mouse, and PCI bus are ignored. 02301 02302 Arguments: 02303 02304 DevNodeInfoList - Array of BIOS_DEVNODE_INFO structures, one for each device 02305 reported by the BIOS. 02306 02307 NumberNodes - Number of BIOS_DEVNODE_INFO elements pointed to by 02308 DevNodeInfoList. 02309 02310 Return Value: 02311 02312 STATUS_SUCCESS if no errors, otherwise the appropriate error. 02313 02314 --*/ 02315 { 02316 PKEY_VALUE_FULL_INFORMATION excludeList=NULL; 02317 02318 UNICODE_STRING enumRootKeyName; 02319 HANDLE enumRootKey; 02320 WCHAR instanceNameStr[DEFAULT_STRING_SIZE]; 02321 UNICODE_STRING instanceKeyName; 02322 HANDLE instanceKey; 02323 UNICODE_STRING controlKeyName; 02324 HANDLE controlKey; 02325 UNICODE_STRING logConfKeyName; 02326 HANDLE logConfKey; 02327 02328 UNICODE_STRING valueName; 02329 ULONG dwordValue; 02330 ULONG disposition; 02331 02332 PWCHAR descriptionStr; 02333 ULONG descriptionStrLength; 02334 02335 ULONG nodeIndex; 02336 NTSTATUS status; 02337 02338 BOOLEAN isNewDevice; 02339 02340 RtlInitUnicodeString(&enumRootKeyName, ENUMROOT_KEY_NAME); 02341 02342 status = IopOpenRegistryKeyEx( &enumRootKey, 02343 NULL, 02344 &enumRootKeyName, 02345 KEY_ALL_ACCESS 02346 ); 02347 02348 if (!NT_SUCCESS(status)) { 02349 02350 DebugPrint( (MAPPER_ERROR, 02351 "Could not open registry key %S, status = %8.8X\n", 02352 ENUMROOT_KEY_NAME, 02353 status) ); 02354 02355 return STATUS_UNSUCCESSFUL; 02356 02357 } 02358 02359 // 02360 // Reasons why a node might be excluded (i.e not enumerated) 02361 // * included in ExcludedDevices array (non-conditional) 02362 // * included in CCS\Control\BiosInfo\PnpBios\DisableNodes via biosinfo.inf 02363 // * resources are disabled and device is included in the 02364 // ExcludeIfDisabled array 02365 02366 PnPGetDevnodeExcludeList (&excludeList); 02367 02368 for (nodeIndex = 0; nodeIndex < NumberNodes; nodeIndex++) { 02369 02370 // 02371 // Check if this node is in the 'ignore on this machine' list. 02372 // 02373 02374 if ( excludeList && 02375 PnPBiosIgnoreNode( &DevNodeInfoList[ nodeIndex ].ProductId[1], 02376 (PWCHAR)((PUCHAR)excludeList+excludeList->DataOffset))) { 02377 continue; 02378 } 02379 02380 // Checking for nodes we always exclude 02381 if ( PnPBiosCheckForExclusion( ExcludedDevices, 02382 EXCLUDED_DEVICES_COUNT, 02383 DevNodeInfoList[ nodeIndex ].ProductId, 02384 DevNodeInfoList[ nodeIndex ].CompatibleIDs)) { 02385 // 02386 // If we are skipping the device, we need to first copy the decode 02387 // info that the BIOS supplied to the ntdetected device's Boot 02388 // Config which was generated by the FW mapper. 02389 // 02390 PnPBiosCopyIoDecode( enumRootKey, &DevNodeInfoList[ nodeIndex ] ); 02391 02392 // 02393 // Skip excluded devices, ie busses, mice and keyboards for now. 02394 // 02395 02396 continue; 02397 } 02398 02399 // Checking for nodes we exclude if disabled 02400 if ( DevNodeInfoList[ nodeIndex ].FirmwareDisabled && 02401 PnPBiosCheckForExclusion( ExcludeIfDisabled, 02402 EXCLUDE_DISABLED_COUNT, 02403 DevNodeInfoList[ nodeIndex ].ProductId, 02404 NULL)) { 02405 continue; 02406 } 02407 02408 swprintf( instanceNameStr, 02409 L"%s\\%s%d", 02410 DevNodeInfoList[ nodeIndex ].ProductId, 02411 INSTANCE_ID_PREFIX, 02412 DevNodeInfoList[ nodeIndex ].Handle ); 02413 02414 RtlInitUnicodeString( &instanceKeyName, instanceNameStr ); 02415 02416 status = IopCreateRegistryKeyEx( &instanceKey, 02417 enumRootKey, 02418 &instanceKeyName, 02419 KEY_ALL_ACCESS, 02420 REG_OPTION_NON_VOLATILE, 02421 &disposition 02422 ); 02423 02424 if (NT_SUCCESS(status)) { 02425 02426 isNewDevice = disposition == REG_CREATED_NEW_KEY; 02427 02428 if (isNewDevice) { 02429 02430 RtlInitUnicodeString( &valueName, L"DeviceDesc" ); 02431 02432 descriptionStr = PnPBiosGetDescription( &DevNodeInfoList[ nodeIndex ] ); 02433 descriptionStrLength = wcslen(descriptionStr) * 2 + sizeof(UNICODE_NULL); 02434 02435 status = ZwSetValueKey( instanceKey, 02436 &valueName, 02437 0, 02438 REG_SZ, 02439 descriptionStr, 02440 descriptionStrLength ); 02441 } 02442 02443 RtlInitUnicodeString( &valueName, REGSTR_VAL_FIRMWAREIDENTIFIED ); 02444 dwordValue = 1; 02445 02446 status = ZwSetValueKey( instanceKey, 02447 &valueName, 02448 0, 02449 REG_DWORD, 02450 &dwordValue, 02451 sizeof(dwordValue) ); 02452 02453 if (isNewDevice) { 02454 02455 RtlInitUnicodeString( &valueName, L"HardwareID" ); 02456 02457 status = ZwSetValueKey( instanceKey, 02458 &valueName, 02459 0, 02460 REG_MULTI_SZ, 02461 DevNodeInfoList[ nodeIndex ].ProductId, 02462 sizeof(DevNodeInfoList[ nodeIndex ].ProductId) ); 02463 02464 if (DevNodeInfoList[ nodeIndex ].CompatibleIDs != NULL) { 02465 02466 RtlInitUnicodeString( &valueName, L"CompatibleIDs" ); 02467 02468 status = ZwSetValueKey( instanceKey, 02469 &valueName, 02470 0, 02471 REG_MULTI_SZ, 02472 DevNodeInfoList[ nodeIndex ].CompatibleIDs, 02473 DevNodeInfoList[ nodeIndex ].CompatibleIDsLength ); 02474 } 02475 } 02476 02477 RtlInitUnicodeString( &valueName, L"Replaces" ); 02478 02479 if (DevNodeInfoList[ nodeIndex ].Replaces != NULL) { 02480 02481 status = ZwSetValueKey( instanceKey, 02482 &valueName, 02483 0, 02484 REG_SZ, 02485 DevNodeInfoList[ nodeIndex ].Replaces, 02486 wcslen(DevNodeInfoList[ nodeIndex ].Replaces) * 2 + sizeof(UNICODE_NULL) ); 02487 02488 } else if (!isNewDevice) { 02489 02490 status = ZwDeleteValueKey( instanceKey, 02491 &valueName ); 02492 } 02493 02494 RtlInitUnicodeString( &controlKeyName, REGSTR_KEY_DEVICECONTROL ); 02495 02496 status = IopCreateRegistryKeyEx( &controlKey, 02497 instanceKey, 02498 &controlKeyName, 02499 KEY_ALL_ACCESS, 02500 REG_OPTION_VOLATILE, 02501 NULL 02502 ); 02503 02504 if (NT_SUCCESS(status)) { 02505 02506 RtlInitUnicodeString( &valueName, REGSTR_VAL_FIRMWAREMEMBER ); 02507 dwordValue = 1; 02508 02509 status = ZwSetValueKey( controlKey, 02510 &valueName, 02511 0, 02512 REG_DWORD, 02513 &dwordValue, 02514 sizeof(dwordValue) ); 02515 02516 RtlInitUnicodeString( &valueName, L"PnpBiosDeviceHandle" ); 02517 dwordValue = DevNodeInfoList[ nodeIndex ].Handle; 02518 02519 status = ZwSetValueKey( controlKey, 02520 &valueName, 02521 0, 02522 REG_DWORD, 02523 &dwordValue, 02524 sizeof(dwordValue) ); 02525 02526 RtlInitUnicodeString( &valueName, REGSTR_VAL_FIRMWAREDISABLED ); 02527 dwordValue = DevNodeInfoList[ nodeIndex ].FirmwareDisabled; 02528 02529 status = ZwSetValueKey( controlKey, 02530 &valueName, 02531 0, 02532 REG_DWORD, 02533 &dwordValue, 02534 sizeof(dwordValue) ); 02535 02536 RtlInitUnicodeString( &valueName, L"PnpBiosDeviceHandle" ); 02537 dwordValue = DevNodeInfoList[ nodeIndex ].Handle; 02538 02539 ZwClose( controlKey ); 02540 02541 } else { 02542 02543 DebugPrint( (MAPPER_ERROR, 02544 "Could not open registry key %S\\%S\\%S\\Control, status = %8.8X\n", 02545 ENUMROOT_KEY_NAME, 02546 DevNodeInfoList[ nodeIndex ].ProductId, 02547 instanceNameStr, 02548 status) ); 02549 02550 ZwClose( instanceKey ); 02551 status = STATUS_UNSUCCESSFUL; 02552 02553 goto Cleanup; 02554 } 02555 02556 RtlInitUnicodeString( &logConfKeyName, REGSTR_KEY_LOGCONF ); 02557 02558 status = IopCreateRegistryKeyEx( &logConfKey, 02559 instanceKey, 02560 &logConfKeyName, 02561 KEY_ALL_ACCESS, 02562 REG_OPTION_NON_VOLATILE, 02563 NULL 02564 ); 02565 02566 if (NT_SUCCESS(status)) { 02567 02568 if (DevNodeInfoList[ nodeIndex ].BootConfig != NULL) { 02569 02570 RtlInitUnicodeString( &valueName, REGSTR_VAL_BOOTCONFIG ); 02571 02572 status = ZwSetValueKey( logConfKey, 02573 &valueName, 02574 0, 02575 REG_RESOURCE_LIST, 02576 DevNodeInfoList[ nodeIndex ].BootConfig, 02577 DevNodeInfoList[ nodeIndex ].BootConfigLength ); 02578 02579 } 02580 02581 if (DevNodeInfoList[ nodeIndex ].BasicConfig != NULL) { 02582 02583 RtlInitUnicodeString( &valueName, REGSTR_VAL_BASICCONFIGVECTOR ); 02584 02585 status = ZwSetValueKey( logConfKey, 02586 &valueName, 02587 0, 02588 REG_RESOURCE_REQUIREMENTS_LIST, 02589 DevNodeInfoList[ nodeIndex ].BasicConfig, 02590 DevNodeInfoList[ nodeIndex ].BasicConfigLength ); 02591 02592 } 02593 02594 ZwClose( logConfKey ); 02595 02596 } else { 02597 02598 DebugPrint( (MAPPER_ERROR, 02599 "Could not open registry key %S\\%S\\%S\\LogConf, status = %8.8X\n", 02600 ENUMROOT_KEY_NAME, 02601 DevNodeInfoList[ nodeIndex ].ProductId, 02602 instanceNameStr, 02603 status) ); 02604 02605 ZwClose( instanceKey ); 02606 status = STATUS_UNSUCCESSFUL; 02607 02608 goto Cleanup; 02609 } 02610 02611 // 02612 // If we are replacing a FW Mapper devnode we need to copy the 02613 // Device Parameters subkey. 02614 // 02615 if (isNewDevice && DevNodeInfoList[ nodeIndex ].Replaces != NULL) { 02616 02617 status = PnPBiosCopyDeviceParamKey( enumRootKey, 02618 DevNodeInfoList[ nodeIndex ].Replaces, 02619 instanceNameStr ); 02620 } 02621 02622 ZwClose( instanceKey ); 02623 02624 } else { 02625 02626 DebugPrint( (MAPPER_ERROR, 02627 "Could not open registry key %S\\%S\\%S, status = %8.8X\n", 02628 ENUMROOT_KEY_NAME, 02629 DevNodeInfoList[ nodeIndex ].ProductId, 02630 instanceNameStr, 02631 status) ); 02632 02633 ZwClose( instanceKey ); 02634 status = STATUS_UNSUCCESSFUL; 02635 02636 goto Cleanup; 02637 } 02638 02639 // 02640 // Now check if the entry just written duplicates one written by the 02641 // Firmware Mapper. If it does then remove the Firmware Mapper entry. 02642 // 02643 02644 if (DevNodeInfoList[ nodeIndex ].Replaces != NULL) { 02645 02646 IopDeleteKeyRecursive( enumRootKey, DevNodeInfoList[ nodeIndex ].Replaces ); 02647 02648 } 02649 } 02650 02651 status = STATUS_SUCCESS; 02652 02653 Cleanup: 02654 ZwClose( enumRootKey ); 02655 02656 if (excludeList) { 02657 ExFreePool (excludeList); 02658 } 02659 02660 return status; 02661 } VOID

BOOLEAN PnPCheckFixedIoOverrideDecodes (  VOID   )

Definition at line 788 of file pnpmap.c. References ASSERT, BIOSINFO_KEY_NAME, DECODEINFO_VALUE_NAME, ExFreePool(), FALSE, IopGetRegistryValue(), IopOpenRegistryKeyEx(), NT_SUCCESS, NTSTATUS(), NULL, and RtlInitUnicodeString(). Referenced by PnPBiosTranslateInfo(). { PKEY_VALUE_FULL_INFORMATION decodeFlagInfo=NULL; UNICODE_STRING biosKeyName; HANDLE biosKey; NTSTATUS status; BOOLEAN overrideDecodes = FALSE; RtlInitUnicodeString(&biosKeyName, BIOSINFO_KEY_NAME); status = IopOpenRegistryKeyEx( &biosKey, NULL, &biosKeyName, KEY_READ ); if (!NT_SUCCESS(status)) { // // Don't really need to complain, likely not there. // return FALSE; } status = IopGetRegistryValue(biosKey, DECODEINFO_VALUE_NAME, &decodeFlagInfo); if (NT_SUCCESS(status)) { ASSERT(decodeFlagInfo->Type == REG_DWORD); if (decodeFlagInfo->DataLength == sizeof(ULONG)) { overrideDecodes = (BOOLEAN) *((PULONG) decodeFlagInfo->Name); } } if (decodeFlagInfo) { ExFreePool(decodeFlagInfo); } ZwClose (biosKey); return overrideDecodes; }

VOID PnPGetDevnodeExcludeList (  OUT PKEY_VALUE_FULL_INFORMATION *  ExcludeList  )

Definition at line 759 of file pnpmap.c. References BIOSINFO_KEY_NAME, BIOSINFO_VALUE_NAME, IopGetRegistryValue(), IopOpenRegistryKeyEx(), NT_SUCCESS, NTSTATUS(), NULL, RtlInitUnicodeString(), and VOID(). Referenced by PnPBiosWriteInfo(). { UNICODE_STRING biosKeyName; HANDLE biosKey; NTSTATUS status; RtlInitUnicodeString(&biosKeyName, BIOSINFO_KEY_NAME); status = IopOpenRegistryKeyEx( &biosKey, NULL, &biosKeyName, KEY_READ ); if (!NT_SUCCESS(status)) { // // Don't really need to complain, likely not there. // return; } (VOID) IopGetRegistryValue (biosKey,BIOSINFO_VALUE_NAME,ExcludeList); ZwClose (biosKey); }

VOID PpFilterNtResource (  IN PWCHAR  PnpDeviceName, PIO_RESOURCE_REQUIREMENTS_LIST  ResReqList )

Definition at line 3065 of file pnpmap.c. References KeI386MachineType, L, and NULL. Referenced by PnPBiosTranslateInfo(). { PIO_RESOURCE_LIST ioResourceList; PIO_RESOURCE_DESCRIPTOR ioResourceDescriptors; if (ResReqList == NULL) { return; } if (IsNEC_98) { return; } #if 0 //_X86_ if (KeI386MachineType == MACHINE_TYPE_EISA) { PCM_FULL_RESOURCE_DESCRIPTOR fullDescriptor; PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptor; PUCHAR nextDescriptor; ULONG j; ULONG lastResourceIndex; fullDescriptor = &ResourceList->List[0]; for (i = 0; i < ResourceList->Count; i++) { partialResourceList = &fullDescriptor->PartialResourceList; for (j = 0; j < partialResourceList->Count; j++) { partialDescriptor = &partialResourceList->PartialDescriptors[j]; if (partialDescriptor->Type == CmResourceTypePort) { if (partialDescriptor->u.Port.Start.HighPart == 0 && (partialDescriptor->u.Port.Start.LowPart & 0x00000300) == 0) { partialDescriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE; } } } nextDescriptor = (PUCHAR)fullDescriptor + sizeof(CM_FULL_RESOURCE_DESCRIPTOR); // // account for any resource descriptors in addition to the single // imbedded one I've already accounted for (if there aren't any, // then I'll end up subtracting off the extra imbedded descriptor // from the previous step) // // // finally, account for any extra device specific data at the end of // the last partial resource descriptor (if any) // if (partialResourceList->Count > 0) { nextDescriptor += (partialResourceList->Count - 1) * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR); lastResourceIndex = partialResourceList->Count - 1; if (partialResourceList->PartialDescriptors[lastResourceIndex].Type == CmResourceTypeDeviceSpecific) { nextDescriptor += partialResourceList->PartialDescriptors[lastResourceIndex]. u.DeviceSpecificData.DataSize; } } fullDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)nextDescriptor; } } #endif if (RtlCompareMemory(PnpDeviceName, L"*PNP06", sizeof(L"*PNP06") - sizeof(WCHAR)) == sizeof(L"*PNP06") - sizeof(WCHAR)) { ULONG i, j; ioResourceList = ResReqList->List; for (j = 0; j < ResReqList->AlternativeLists; j++) { ioResourceDescriptors = ioResourceList->Descriptors; for (i = 0; i < ioResourceList->Count; i++) { if (ioResourceDescriptors[i].Type == CmResourceTypePort) { // // some bios asks for 1 too many io port for ide channel // if ((ioResourceDescriptors[i].u.Port.Length == 2) && (ioResourceDescriptors[i].u.Port.MaximumAddress.QuadPart == (ioResourceDescriptors[i].u.Port.MinimumAddress.QuadPart + 1))) { ioResourceDescriptors[i].u.Port.Length = 1; ioResourceDescriptors[i].u.Port.MaximumAddress = ioResourceDescriptors[i].u.Port.MinimumAddress; } } } ioResourceList = (PIO_RESOURCE_LIST) (ioResourceDescriptors + ioResourceList->Count); } } }

---

Variable Documentation

CLASSDATA Class10Descriptions[]

Initial value: { { 0x0000, L"Generic dock" }, { 0x8000, L"Other dock" }, } Definition at line 211 of file pnpmap.c.

CLASSDATA Class11Descriptions[]

Initial value: { { 0x0000, L"386" }, { 0x0100, L"486" }, { 0x0200, L"Pentium" }, { 0x1000, L"Alpha" }, { 0x4000, L"Co-processor" } } Definition at line 216 of file pnpmap.c.

CLASSDATA Class12Descriptions[]

Initial value: { { 0x0000, L"Firewire" }, { 0x0100, L"Access bus" }, { 0x0200, L"SSA" }, { 0x8000, L"Other serial bus" } } Definition at line 224 of file pnpmap.c.

CLASSDATA Class1Descriptions[]

Initial value: { { 0x0000, L"SCSI Controller" }, { 0x0100, L"IDE Controller" }, { 0x0200, L"Floppy Controller" }, { 0x0300, L"IPI Controller" }, { 0x0400, L"RAID Controller" }, { 0x8000, L"Other Mass Storage" } } Definition at line 131 of file pnpmap.c.

CLASSDATA Class2Descriptions[]

Initial value: { { 0x0000, L"Ethernet" }, { 0x0100, L"Token ring" }, { 0x0200, L"FDDI" }, { 0x0300, L"ATM" }, { 0x8000, L"Other network" } } Definition at line 140 of file pnpmap.c.

CLASSDATA Class3Descriptions[]

Initial value: { { 0x0000, L"VGA" }, { 0x0001, L"SVGA" }, { 0x0100, L"XGA" }, { 0x8000, L"Other display" } } Definition at line 148 of file pnpmap.c.

CLASSDATA Class4Descriptions[]

Initial value: { { 0x0000, L"Video device" }, { 0x0100, L"Audio device" }, { 0x8000, L"Other multimedia" } } Definition at line 155 of file pnpmap.c.

CLASSDATA Class5Descriptions[]

Initial value: { { 0x0000, L"RAM memory" }, { 0x0100, L"Flash memory" }, { 0x8000, L"Other memory" } } Definition at line 161 of file pnpmap.c.

CLASSDATA Class6Descriptions[]

Initial value: { { 0x0000, L"HOST / PCI" }, { 0x0100, L"PCI / ISA" }, { 0x0200, L"PCI / EISA" }, { 0x0300, L"PCI / MCA" }, { 0x0400, L"PCI / PCI" }, { 0x0500, L"PCI / PCMCIA" }, { 0x0600, L"NuBus" }, { 0x0700, L"Cardbus" }, { 0x8000, L"Other bridge" } } Definition at line 167 of file pnpmap.c.

CLASSDATA Class7Descriptions[]

Initial value: { { 0x0000, L"XT Serial" }, { 0x0001, L"16450" }, { 0x0002, L"16550" }, { 0x0100, L"Parallel output only" }, { 0x0101, L"BiDi Parallel" }, { 0x0102, L"ECP 1.x parallel" }, { 0x8000, L"Other comm" } } Definition at line 179 of file pnpmap.c.

CLASSDATA Class8Descriptions[]

Initial value: { { 0x0000, L"Generic 8259" }, { 0x0001, L"ISA PIC" }, { 0x0002, L"EISA PIC" }, { 0x0100, L"Generic 8237" }, { 0x0101, L"ISA DMA" }, { 0x0102, L"EISA DMA" }, { 0x0200, L"Generic 8254" }, { 0x0201, L"ISA timer" }, { 0x0202, L"EISA timer" }, { 0x0300, L"Generic RTC" }, { 0x0301, L"ISA RTC" }, { 0x8000, L"Other system device" } } Definition at line 189 of file pnpmap.c.

CLASSDATA Class9Descriptions[]

Initial value: { { 0x0000, L"Keyboard" }, { 0x0100, L"Digitizer" }, { 0x0200, L"Mouse" }, { 0x8000, L"Other input" } } Definition at line 204 of file pnpmap.c.

struct _CLASS_DESCRIPTIONS_LIST ClassDescriptionsList[]

Referenced by PnPBiosGetDescription().

EXCLUDED_PNPNODE ExcludedDevices[]

Initial value: { EXCLUSION_ENTRY(L"*PNP03"), EXCLUSION_ENTRY(L"*PNP0A"), EXCLUSION_ENTRY(L"*PNP0E"), EXCLUSION_ENTRY(L"*PNP0F"), EXCLUSION_ENTRY(L"*nEC13"), EXCLUSION_ENTRY(L"*nEC1E"), EXCLUSION_ENTRY(L"*nEC1F"), EXCLUSION_ENTRY(L"*IBM3780"), EXCLUSION_ENTRY(L"*IBM3781") } Definition at line 105 of file pnpmap.c. Referenced by PnPBiosWriteInfo().

EXCLUDED_PNPNODE ExcludeIfDisabled[]

Initial value: { EXCLUSION_ENTRY(L"*PNP0C01"), EXCLUSION_ENTRY(L"*PNP0C02") } Definition at line 119 of file pnpmap.c. Referenced by PnPBiosWriteInfo().

---