mapper.c File Reference

#include "iop.h"

Go to the source code of this file.

Classes
struct	_FIRMWARE_CONFIGURATION
struct	_DEVICE_EXTENSION
struct	_FIRMWARE_IDENT_TO_PNP_ID
struct	_MAPPER_SEED
struct	_KEY_SEED
Defines
#define	OPTIONS_NONE   0x00000000
#define	OPTIONS_INSERT_PNP_ID   0x00000001
#define	OPTIONS_INSERT_DEVICEDESC   0x00000002
#define	OPTIONS_INSERT_COMPATIBLE_IDS   0x00000004
#define	OPTIONS_INSERT_PHANTOM_MARKER   0x00000008
#define	KEY_SEED_REQUIRED   0x00000000
#define	KEY_SEED_DEVICE_PARAMETERS   0x00000001
#define	PS2_KEYBOARD_COMPATIBLE_ID   L"PS2_KEYBOARD"
#define	PS2_MOUSE_COMPATIBLE_ID   L"PS2_MOUSE"
#define	DebugPrint(X)
#define	CONTROLLER_TYPES_COUNT   (sizeof(controllerTypes) / sizeof(controllerTypes[0]))
#define	SEED_BUFFER_SIZE   (512 * sizeof(WCHAR))
#define	ENUM_KEY_BUFFER_SIZE   (1024 * sizeof(WCHAR))
#define	INSTANCE_BUFFER_SIZE   (256 * sizeof(WCHAR))
#define	COMPORT_DB_MERGE_SIZE   32
Typedefs
typedef _FIRMWARE_CONFIGURATION	FIRMWARE_CONFIGURATION
typedef _FIRMWARE_CONFIGURATION *	PFIRMWARE_CONFIGURATION
typedef _DEVICE_EXTENSION	DEVICE_EXTENSION
typedef _DEVICE_EXTENSION *	PDEVICE_EXTENSION
typedef _FIRMWARE_IDENT_TO_PNP_ID	FIRMWARE_IDENT_TO_PNP_ID
typedef _FIRMWARE_IDENT_TO_PNP_ID *	PFIRMWARE_IDENT_TO_PNP_ID
typedef _MAPPER_SEED	MAPPER_SEED
typedef _MAPPER_SEED *	PMAPPER_SEED
typedef _KEY_SEED	KEY_SEED
typedef _KEY_SEED *	PKEY_SEED
Functions
PFIRMWARE_IDENT_TO_PNP_ID	MapperFindIdentMatch (PFIRMWARE_IDENT_TO_PNP_ID IdentTable, PWCHAR String)
PWSTR	MapperTranslatePnPId (CONFIGURATION_TYPE PeripheralType, PKEY_VALUE_FULL_INFORMATION Identifier)
NTSTATUS	MapperPeripheralCallback (IN PVOID Context, IN PUNICODE_STRING PathName, IN INTERFACE_TYPE BusType, IN ULONG BusNumber, IN PKEY_VALUE_FULL_INFORMATION *BusInformation, IN CONFIGURATION_TYPE ControllerType, IN ULONG ControllerNumber, IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation, IN CONFIGURATION_TYPE PeripheralType, IN ULONG PeripheralNumber, IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation)
NTSTATUS	MapperCallback (IN PVOID Context, IN PUNICODE_STRING PathName, IN INTERFACE_TYPE BusType, IN ULONG BusNumber, IN PKEY_VALUE_FULL_INFORMATION *BusInformation, IN CONFIGURATION_TYPE ControllerType, IN ULONG ControllerNumber, IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation, IN CONFIGURATION_TYPE PeripheralType, IN ULONG PeripheralNumber, IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation)
VOID	MapperMarkKey (IN HANDLE Handle, IN PUNICODE_STRING PathName, IN PFIRMWARE_CONFIGURATION FirmwareEntry)
VOID	MapperSeedKey (IN HANDLE Handle, IN PUNICODE_STRING PathName, IN PFIRMWARE_CONFIGURATION FirmwareEntry, IN BOOLEAN DeviceIsPhantom)
PCM_RESOURCE_LIST	MapperAdjustResourceList (IN PCM_RESOURCE_LIST ResourceList, IN PWCHAR PnPId, IN OUT PULONG Size)
NTSTATUS	ComPortDBAdd (IN HANDLE DeviceParamKey, IN PWSTR PortName)
VOID	MapperProcessFirmwareTree (IN BOOLEAN OnlyProcessSerialPorts)
VOID	MapperFreeList (VOID)
VOID	MapperConstructRootEnumTree (IN BOOLEAN CreatePhantomDevices)
VOID	MapperPhantomizeDetectedComPorts (VOID)
Variables
DEVICE_EXTENSION	MapperDeviceExtension
FIRMWARE_IDENT_TO_PNP_ID	KeyboardMap []
FIRMWARE_IDENT_TO_PNP_ID	PointerMap []
MAPPER_SEED	MapperValueSeed []
KEY_SEED	MapperKeySeed []
PWSTR	SerialId = L"*PNP0501"
PWSTR	SerialIdNEC []
PWSTR	ParallelId = L"*PNP0400"
PWSTR	ParallelIdNEC = L"*nEC1401"
PWSTR	FloppyId = L"*PNP0700"
PWSTR	ATAId = L"*PNP0600"

---

Define Documentation

#define COMPORT_DB_MERGE_SIZE   32

Referenced by ComPortDBAdd().

#define CONTROLLER_TYPES_COUNT   (sizeof(controllerTypes) / sizeof(controllerTypes[0]))

Referenced by MapperProcessFirmwareTree().

#define DebugPrint (  X   )

Definition at line 272 of file mapper.c.

#define ENUM_KEY_BUFFER_SIZE   (1024 * sizeof(WCHAR))

Referenced by MapperConstructRootEnumTree(), and MapperPhantomizeDetectedComPorts().

#define INSTANCE_BUFFER_SIZE   (256 * sizeof(WCHAR))

Referenced by MapperConstructRootEnumTree(), and MapperPhantomizeDetectedComPorts().

#define KEY_SEED_DEVICE_PARAMETERS   0x00000001

Definition at line 106 of file mapper.c. Referenced by MapperSeedKey().

#define KEY_SEED_REQUIRED   0x00000000

Definition at line 105 of file mapper.c.

#define OPTIONS_INSERT_COMPATIBLE_IDS   0x00000004

Definition at line 91 of file mapper.c. Referenced by MapperSeedKey().

#define OPTIONS_INSERT_DEVICEDESC   0x00000002

Definition at line 90 of file mapper.c. Referenced by MapperSeedKey().

#define OPTIONS_INSERT_PHANTOM_MARKER   0x00000008

Definition at line 92 of file mapper.c. Referenced by MapperSeedKey().

#define OPTIONS_INSERT_PNP_ID   0x00000001

Definition at line 89 of file mapper.c. Referenced by MapperSeedKey().

#define OPTIONS_NONE   0x00000000

Definition at line 88 of file mapper.c.

#define PS2_KEYBOARD_COMPATIBLE_ID   L"PS2_KEYBOARD"

Definition at line 148 of file mapper.c. Referenced by MapperSeedKey().

#define PS2_MOUSE_COMPATIBLE_ID   L"PS2_MOUSE"

Definition at line 149 of file mapper.c. Referenced by MapperSeedKey().

#define SEED_BUFFER_SIZE   (512 * sizeof(WCHAR))

Referenced by MapperSeedKey().

---

Typedef Documentation

typedef struct _DEVICE_EXTENSION DEVICE_EXTENSION

typedef struct _FIRMWARE_CONFIGURATION FIRMWARE_CONFIGURATION

Referenced by MapperCallback().

typedef struct _FIRMWARE_IDENT_TO_PNP_ID FIRMWARE_IDENT_TO_PNP_ID

typedef struct _KEY_SEED KEY_SEED

typedef struct _MAPPER_SEED MAPPER_SEED

typedef struct _DEVICE_EXTENSION * PDEVICE_EXTENSION

typedef struct _FIRMWARE_CONFIGURATION * PFIRMWARE_CONFIGURATION

Referenced by MapperCallback(), MapperConstructRootEnumTree(), MapperFreeList(), MapperPeripheralCallback(), and MapperPhantomizeDetectedComPorts().

typedef struct _FIRMWARE_IDENT_TO_PNP_ID * PFIRMWARE_IDENT_TO_PNP_ID

Referenced by MapperFindIdentMatch(), and MapperTranslatePnPId().

typedef struct _KEY_SEED * PKEY_SEED

Referenced by MapperSeedKey().

typedef struct _MAPPER_SEED * PMAPPER_SEED

Referenced by MapperSeedKey().

---

Function Documentation

NTSTATUS ComPortDBAdd (  IN HANDLE  DeviceParamKey, IN PWSTR  PortName )

Definition at line 1955 of file mapper.c. References ASSERT, COMPORT_DB_MERGE_SIZE, ExAllocatePool, ExFreePool(), IopCreateRegistryKeyEx(), L, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, PortName, RtlCompareUnicodeString(), RtlInitUnicodeString(), and TRUE. { UNICODE_STRING portNameString; UNICODE_STRING portPrefixString; UNICODE_STRING comDBName; UNICODE_STRING valueName; PKEY_VALUE_PARTIAL_INFORMATION valueInfo; ULONG valueInfoLength; ULONG returnedLength; HANDLE comDBKey; ULONG portNo; NTSTATUS status; RtlInitUnicodeString(&portNameString, PortName); if (portNameString.Length > 3 * sizeof(WCHAR)) { portNameString.Length = 3 * sizeof(WCHAR); } RtlInitUnicodeString(&portPrefixString, L"COM"); if (RtlCompareUnicodeString(&portNameString, &portPrefixString, TRUE) == 0) { portNo = _wtol(&PortName[3]); if (portNo > 0 && portNo <= 256) { #if UMODETEST RtlInitUnicodeString(&comDBName, L"\\Registry\\Machine\\System\\TestControlSet\\Control\\COM Name Arbiter"); #else RtlInitUnicodeString(&comDBName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\COM Name Arbiter"); #endif status = IopCreateRegistryKeyEx( &comDBKey, NULL, &comDBName, KEY_ALL_ACCESS, REG_OPTION_NON_VOLATILE, NULL ); if (NT_SUCCESS(status)) { RtlInitUnicodeString(&valueName, L"ComDB Merge"); #define COMPORT_DB_MERGE_SIZE 32 // 256 / 8 valueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + COMPORT_DB_MERGE_SIZE; valueInfo = ExAllocatePool(PagedPool, valueInfoLength); if (valueInfo != NULL) { status = ZwQueryValueKey( comDBKey, &valueName, KeyValuePartialInformation, valueInfo, valueInfoLength, &returnedLength); if (status == STATUS_OBJECT_NAME_NOT_FOUND) { valueInfo->Type = REG_BINARY; valueInfo->DataLength = COMPORT_DB_MERGE_SIZE; RtlZeroMemory(valueInfo->Data, valueInfo->DataLength); status = STATUS_SUCCESS; } if (NT_SUCCESS(status)) { portNo--; valueInfo->Data[ portNo / 8 ] |= 1 << (portNo % 8); status = ZwSetValueKey( comDBKey, &valueName, 0, valueInfo->Type, valueInfo->Data, valueInfo->DataLength ); ASSERT(NT_SUCCESS(status)); } ExFreePool(valueInfo); } ZwClose(comDBKey); } } } RtlInitUnicodeString( &valueName, L"PortName" ); status = ZwSetValueKey( DeviceParamKey, &valueName, 0, REG_SZ, PortName, (wcslen(PortName) + 1) * sizeof(WCHAR) ); return status; }

PCM_RESOURCE_LIST MapperAdjustResourceList (  IN PCM_RESOURCE_LIST  ResourceList, IN PWCHAR  PnPId, IN OUT PULONG  Size )

Definition at line 1803 of file mapper.c. References ExAllocatePool, ExFreePool(), FloppyId, KeI386MachineType, NonPagedPool, NULL, and Size. Referenced by MapperMarkKey(). { PCM_PARTIAL_RESOURCE_LIST partialResourceList; PCM_PARTIAL_RESOURCE_DESCRIPTOR problemPartialDescriptors; PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptors; PCM_RESOURCE_LIST newResourceList; ULONG i; newResourceList = ResourceList; #if _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 (wcscmp(PnPId, FloppyId) == 0) { if (ResourceList->Count == 1) { partialResourceList = &ResourceList->List->PartialResourceList; partialDescriptors = partialResourceList->PartialDescriptors; // // Look for the one and only one 8 byte port resource // problemPartialDescriptors = NULL; for (i=0; i<partialResourceList->Count; i++) { if ((partialDescriptors[i].Type == CmResourceTypePort) && (partialDescriptors[i].u.Port.Length == 8)) { if (problemPartialDescriptors == NULL) { problemPartialDescriptors = partialDescriptors + i; } else { problemPartialDescriptors = NULL; break; } } } if (problemPartialDescriptors) { problemPartialDescriptors->u.Port.Length = 6; newResourceList = ExAllocatePool ( NonPagedPool, *Size + sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) ); if (newResourceList) { RtlMoveMemory ( newResourceList, ResourceList, *Size ); // // pick out the new partial resource descriptor // partialDescriptors = newResourceList->List-> PartialResourceList.PartialDescriptors; partialDescriptors += newResourceList->List->PartialResourceList.Count; RtlMoveMemory ( partialDescriptors, problemPartialDescriptors, sizeof(*partialDescriptors) ); partialDescriptors->u.Port.Start.QuadPart += 7; partialDescriptors->u.Port.Length = 1; // // we got one more now // newResourceList->List->PartialResourceList.Count++; *Size += sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR); ExFreePool (ResourceList); } else { newResourceList = ResourceList; } } } } return newResourceList; }

NTSTATUS MapperCallback (  IN PVOID  Context, IN PUNICODE_STRING  PathName, IN INTERFACE_TYPE  BusType, IN ULONG  BusNumber, IN PKEY_VALUE_FULL_INFORMATION *  BusInformation, IN CONFIGURATION_TYPE  ControllerType, IN ULONG  ControllerNumber, IN PKEY_VALUE_FULL_INFORMATION *  ControllerInformation, IN CONFIGURATION_TYPE  PeripheralType, IN ULONG  PeripheralNumber, IN PKEY_VALUE_FULL_INFORMATION *  PeripheralInformation )

Definition at line 658 of file mapper.c. References BusNumber, _FIRMWARE_CONFIGURATION::BusNumber, _FIRMWARE_CONFIGURATION::BusType, CONFIGURATION_TYPE, _FIRMWARE_CONFIGURATION::ControllerNumber, ControllerType, _FIRMWARE_CONFIGURATION::ControllerType, DebugPrint, DiskController, ExAllocatePool, ExFreePool(), FIRMWARE_CONFIGURATION, _DEVICE_EXTENSION::FirmwareList, FloppyDiskPeripheral, _FIRMWARE_CONFIGURATION::Identifier, _FIRMWARE_CONFIGURATION::IdentifierLength, _FIRMWARE_CONFIGURATION::IdentifierType, IoQueryDeviceConfigurationData, IoQueryDeviceDescription(), IoQueryDeviceIdentifier, KeyboardController, KeyboardPeripheral, L, MapperPeripheralCallback(), MapperTranslatePnPId(), _FIRMWARE_CONFIGURATION::Next, NonPagedPool, NULL, ParallelController, ParallelIdNEC, PDEVICE_EXTENSION, _FIRMWARE_CONFIGURATION::PeripheralNumber, _FIRMWARE_CONFIGURATION::PeripheralType, PFIRMWARE_CONFIGURATION, _FIRMWARE_CONFIGURATION::PnPId, PointerController, PointerPeripheral, _FIRMWARE_CONFIGURATION::ResourceDescriptor, _FIRMWARE_CONFIGURATION::ResourceDescriptorSize, SerialController, SerialIdNEC, and USHORT. Referenced by MapperProcessFirmwareTree(). : This routine is used to acquire firmware tree information about pointer devices in the system. Arguments: Context - Pointer to the device extension. PathName - unicode registry path. BusType - Internal, Isa, ... BusNumber - Which bus if we are on a multibus system. BusInformation - Configuration information about the bus. Not Used. ControllerType - serial or ata disk. ControllerNumber - Which controller if there is more than one controller in the system. ControllerInformation - Array of pointers to the three pieces of registry information. PeripheralType - Undefined for this call. PeripheralNumber - Undefined for this call. PeripheralInformation - Undefined for this call. Return Value: STATUS_SUCCESS if everything went ok, or STATUS_INSUFFICIENT_RESOURCES if it couldn't map the base csr or acquire the device object, or all of the resource information couldn't be acquired. --*/ { PDEVICE_EXTENSION deviceExtension = Context; PCM_FULL_RESOURCE_DESCRIPTOR controllerData; PKEY_VALUE_FULL_INFORMATION information; PFIRMWARE_CONFIGURATION firmwareEntry; CONFIGURATION_TYPE peripheralType; PUCHAR buffer; PUCHAR identifier; ULONG dataLength; // // If entry is found, but there is no information just return // if (!(information = ControllerInformation[IoQueryDeviceConfigurationData])) { return STATUS_SUCCESS; } if (!(dataLength = information->DataLength)) { return STATUS_SUCCESS; } // // Setup to capture the information from the firmware tree // firmwareEntry = ExAllocatePool(NonPagedPool, sizeof(FIRMWARE_CONFIGURATION)); if (!firmwareEntry) { return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory(firmwareEntry, sizeof(FIRMWARE_CONFIGURATION)); // // Save information concerning the controller // firmwareEntry->ControllerType = ControllerType; firmwareEntry->ControllerNumber = ControllerNumber; firmwareEntry->BusNumber = BusNumber; firmwareEntry->BusType = BusType; // // Save the resource descriptor // buffer = firmwareEntry->ResourceDescriptor = ExAllocatePool(NonPagedPool, dataLength); if (!buffer) { ExFreePool(firmwareEntry); return STATUS_INSUFFICIENT_RESOURCES; } // // Save the configuration information on this controller. // controllerData = (PCM_FULL_RESOURCE_DESCRIPTOR) ((PUCHAR)information + information->DataOffset); RtlMoveMemory(buffer, controllerData, dataLength); firmwareEntry->ResourceDescriptorSize = dataLength; // // If there is a device identifier save it. // if (information = ControllerInformation[IoQueryDeviceIdentifier]) { PWCHAR ptr; if (dataLength = information->DataLength) { ptr = (PWCHAR) ((PUCHAR)information + information->DataOffset); if (ControllerType == ParallelController) { PWCHAR tmpChar; // // Some extra mapping is performed here to // translate the firmware names to LPT names. // *ptr++ = (WCHAR) 'L'; *ptr++ = (WCHAR) 'P'; *ptr++ = (WCHAR) 'T'; // // Find the number. // tmpChar = ptr; while (*tmpChar) { if ((*tmpChar >= (WCHAR) '0') && (*tmpChar <= (WCHAR) '9')) { break; } tmpChar++; } if (*tmpChar) { while (*tmpChar) { *ptr++ = *tmpChar++; } *ptr = (WCHAR) 0; // // Update the datalength to be 4 wchars and eos and // restore the pointer. // ptr = (PWCHAR) ((PUCHAR)information + information->DataOffset); dataLength = 10; } else { dataLength = 0; DebugPrint((MAPPER_ERROR, "Mapper: no parallel port number!\n")); } } if (dataLength) { firmwareEntry->Identifier = ExAllocatePool(NonPagedPool, dataLength); if (firmwareEntry->Identifier) { // // Move the data // firmwareEntry->IdentifierType = information->Type; firmwareEntry->IdentifierLength = dataLength; RtlMoveMemory(firmwareEntry->Identifier, ptr, dataLength); } } } } // // For some controllers, search the peripheral information // switch (ControllerType) { case SerialController: case ParallelController: // // Don't look for a peripheral. // peripheralType = (CONFIGURATION_TYPE) 0; break; case DiskController: peripheralType = FloppyDiskPeripheral; break; case KeyboardController: peripheralType = KeyboardPeripheral; break; case PointerController: peripheralType = PointerPeripheral; break; default: peripheralType = (CONFIGURATION_TYPE) 0; break; } DebugPrint((MAPPER_REGISTRY, "Mapper: registry location is\n %ws\n", PathName->Buffer)); DebugPrint((MAPPER_INFORMATION, "Mapper: ControllerInformation[] -\n\tIdent: %x -\n\tData: %x -\n\tInformation: %x\n", ControllerInformation[0], ControllerInformation[1], ControllerInformation[2])); if (peripheralType) { DebugPrint((MAPPER_PNP_ID, "Mapper: searching for peripheral type %d\n", peripheralType)); IoQueryDeviceDescription(&BusType, &BusNumber, &ControllerType, &ControllerNumber, &peripheralType, NULL, MapperPeripheralCallback, firmwareEntry); } // // firmwareEntry->PnPId will be NULL if there are no peripherals of this // type in the tree or if the peripheral's description doesn't match one of // those in our table. // // firmwareEntry->PeripheralType will be equal to peripheralType if we found // one of the proper type regardless of whether or not it is in the table. // // So this test just ensures that we fallback to the controller IDs in the // case were there is no peripheral entry. If there is a peripheral entry // that we don't understand we will suppress the entire node. // // This prevents creating devices with hw ids of bogus as we were seeing on // the SGI x86 ARC machines. // if (!firmwareEntry->PnPId && firmwareEntry->PeripheralType == 0) { // // Attempt to get PnPId from the controller type. // firmwareEntry->PnPId = MapperTranslatePnPId(ControllerType, NULL); if (!firmwareEntry->PnPId) { DebugPrint((MAPPER_PNP_ID, "Mapper: NO PnP Id for\n ==> %ws\n", PathName->Buffer)); } } // NEC98 needs DeviceId which differs with the other H/W. if (IsNEC_98){ switch (ControllerType) { case SerialController:{ ULONG i,j; PWSTR serialFirmwareName; serialFirmwareName = ExAllocatePool(NonPagedPool, sizeof(USHORT)*10); if (!serialFirmwareName) { if (buffer) ExFreePool(buffer); if (firmwareEntry) { if (firmwareEntry->Identifier) ExFreePool(firmwareEntry->Identifier); ExFreePool(firmwareEntry); } return STATUS_INSUFFICIENT_RESOURCES; } for ( i = 0; i < controllerData->PartialResourceList.Count; i++ ) { PCM_PARTIAL_RESOURCE_DESCRIPTOR partial = &controllerData->PartialResourceList.PartialDescriptors[i]; if (partial->Type == CmResourceTypeDeviceSpecific) { PCM_SERIAL_DEVICE_DATA sDeviceData; sDeviceData = (PCM_SERIAL_DEVICE_DATA)(partial + 1); swprintf(serialFirmwareName, L"*nEC%04X\0", sDeviceData->Revision); j = 0; while (SerialIdNEC[j]) { if (!wcscmp(serialFirmwareName, SerialIdNEC[j])) { firmwareEntry->PnPId = SerialIdNEC[j]; } j++; } } } ExFreePool(serialFirmwareName); break; } case ParallelController: firmwareEntry->PnPId = ParallelIdNEC; break; default: break; } } DebugPrint((MAPPER_PNP_ID, "Mapper: constructed name %d_%d_%d_%d_%d_%d\n", firmwareEntry->BusType, firmwareEntry->BusNumber, firmwareEntry->ControllerType, firmwareEntry->ControllerNumber, firmwareEntry->PeripheralType, firmwareEntry->PeripheralNumber)); if (firmwareEntry->PnPId) { // // Link into chain of entries. // firmwareEntry->Next = deviceExtension->FirmwareList; deviceExtension->FirmwareList = firmwareEntry; } else { // // No map found - don't remember this entry. // ExFreePool(buffer); if(firmwareEntry->Identifier) { ExFreePool(firmwareEntry->Identifier); } ExFreePool(firmwareEntry); } return STATUS_SUCCESS; }

VOID MapperConstructRootEnumTree (  IN BOOLEAN  CreatePhantomDevices  )

Definition at line 1600 of file mapper.c. References _FIRMWARE_CONFIGURATION::BusNumber, _FIRMWARE_CONFIGURATION::BusType, _FIRMWARE_CONFIGURATION::ControllerNumber, _FIRMWARE_CONFIGURATION::ControllerType, DebugPrint, ENUM_KEY_BUFFER_SIZE, ExAllocatePool, ExFreePool(), FALSE, _DEVICE_EXTENSION::FirmwareList, _FIRMWARE_CONFIGURATION::Identifier, INSTANCE_BUFFER_SIZE, L, MapperDeviceExtension, MapperFreeList(), MapperMarkKey(), MapperSeedKey(), _FIRMWARE_CONFIGURATION::NewlyCreated, _FIRMWARE_CONFIGURATION::Next, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, PDEVICE_EXTENSION, _FIRMWARE_CONFIGURATION::PeripheralNumber, _FIRMWARE_CONFIGURATION::PeripheralType, PFIRMWARE_CONFIGURATION, _FIRMWARE_CONFIGURATION::PnPId, _FIRMWARE_CONFIGURATION::ResourceDescriptor, RtlAppendUnicodeToString(), RtlInitUnicodeString(), and TRUE. Referenced by IopInitializePlugPlayServices(). : This routine walks through the list of firmware entries in the device extension and migrates the information into the root enumerator's tree in the registry. Arguments: CreatePhantomDevices - If non-zero, then the device instances are created as "phantoms" (i.e., they are marked with the "Phantom" value entry so that the root enumerator will ignore them). The only time these device instance registry keys will ever turn into real live devnodes is if the class installer (in response to DIF_FIRSTTIMESETUP or DIF_DETECT) decides that these devices aren't duplicates of any PnP-enumerated devnodes, and subsequently registers and installs them. Return Value: None --*/ { #define ENUM_KEY_BUFFER_SIZE (1024 * sizeof(WCHAR)) #define INSTANCE_BUFFER_SIZE (256 * sizeof(WCHAR)) UNICODE_STRING enumKey; PFIRMWARE_CONFIGURATION firmwareEntry; OBJECT_ATTRIBUTES objectAttributes; NTSTATUS status; BOOLEAN keyPresent; PWCHAR registryBase; PWCHAR instanceBuffer; HANDLE handle; ULONG disposition; PVOID buffer; PDEVICE_EXTENSION DeviceExtension = &MapperDeviceExtension; // // allocate space needed for the registry path into the root // enumerator tree. Note, limited size on path length. // buffer = ExAllocatePool(NonPagedPool, ENUM_KEY_BUFFER_SIZE); if (!buffer) { MapperFreeList(); DebugPrint((MAPPER_ERROR, "Mapper: could not allocate memory for registry update\n")); return; } instanceBuffer = ExAllocatePool(NonPagedPool, INSTANCE_BUFFER_SIZE); if (!instanceBuffer) { MapperFreeList(); ExFreePool(buffer); DebugPrint((MAPPER_ERROR, "Mapper: could not allocate memory for instance buffer\n")); return; } InitializeObjectAttributes(&objectAttributes, &enumKey, OBJ_CASE_INSENSITIVE, NULL, NULL); #if UMODETEST registryBase = L"\\Registry\\Machine\\System\\TestControlSet\\Enum\\Root\\"; #else registryBase = L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\Root\\"; #endif firmwareEntry = DeviceExtension->FirmwareList; while (firmwareEntry) { // // Construct the base for the path for this entry. // RtlInitUnicodeString(&enumKey, NULL); enumKey.MaximumLength = ENUM_KEY_BUFFER_SIZE; enumKey.Buffer = buffer; RtlZeroMemory(buffer, ENUM_KEY_BUFFER_SIZE); RtlAppendUnicodeToString(&enumKey, registryBase); RtlAppendUnicodeToString(&enumKey, firmwareEntry->PnPId); // // Build the pnp Key. // status = ZwCreateKey(&handle, KEY_READ | KEY_WRITE, &objectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, &disposition); if (NT_SUCCESS(status)) { // // Do not need the handle, so close it // Remember if the key was present prior to call // ZwClose(handle); keyPresent = (disposition == REG_OPENED_EXISTING_KEY) ? TRUE : FALSE; DebugPrint((MAPPER_INFORMATION, "Mapper: Key was %s\n", keyPresent ? "Present" : "Created")); // // Construct the instance name. // RtlZeroMemory(instanceBuffer, INSTANCE_BUFFER_SIZE); swprintf(instanceBuffer, L"\\%d_%d_%d_%d_%d_%d", firmwareEntry->BusType, firmwareEntry->BusNumber, firmwareEntry->ControllerType, firmwareEntry->ControllerNumber, firmwareEntry->PeripheralType, firmwareEntry->PeripheralNumber); RtlAppendUnicodeToString(&enumKey, instanceBuffer); status = ZwCreateKey(&handle, KEY_READ | KEY_WRITE, &objectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, &disposition); if (NT_SUCCESS(status)) { if (firmwareEntry->ResourceDescriptor) { DebugPrint((MAPPER_INFORMATION, "Mapper: firmware entry has resources %x\n", firmwareEntry->ResourceDescriptor)); } if (firmwareEntry->Identifier) { DebugPrint((MAPPER_INFORMATION, "Mapper: firmware entry has identifier %x\n", firmwareEntry->Identifier)); } // // Only if this is a new entry do we see the key. // if (disposition == REG_CREATED_NEW_KEY) { // // Remember the fact that the key was newly-created for the // PnP BIOS case where we need to come along and "phantomize" // all newly-created ntdetect COM ports. // firmwareEntry->NewlyCreated = TRUE; // // Create enough information to get pnp to // install drivers // MapperSeedKey(handle, &enumKey, firmwareEntry, CreatePhantomDevices ); } MapperMarkKey(handle, &enumKey, firmwareEntry); ZwClose(handle); } else { DebugPrint((MAPPER_ERROR, "Mapper: create of instance key failed %x\n", status)); } } else { DebugPrint((MAPPER_ERROR, "Mapper: create pnp key failed %x\n", status)); } firmwareEntry = firmwareEntry->Next; } ExFreePool(instanceBuffer); }

PFIRMWARE_IDENT_TO_PNP_ID MapperFindIdentMatch (  PFIRMWARE_IDENT_TO_PNP_ID  IdentTable, PWCHAR  String )

Definition at line 367 of file mapper.c. References _FIRMWARE_IDENT_TO_PNP_ID::FirmwareName, NULL, PFIRMWARE_IDENT_TO_PNP_ID, and String. Referenced by MapperTranslatePnPId(). 00374 : 00375 00376 Given a table of strings to match, find the match for 00377 the identifier given. 00378 00379 Arguments: 00380 00381 Return Value: 00382 00383 A pointer to the ident table entry for the match if found 00384 NULL if not found. 00385 00386 --*/ 00387 00388 { 00389 PFIRMWARE_IDENT_TO_PNP_ID entry; 00390 00391 entry = IdentTable; 00392 while (entry->FirmwareName) { 00393 if (!wcscmp(String, entry->FirmwareName)) { 00394 return entry; 00395 } 00396 entry++; 00397 } 00398 return NULL; 00399 }

VOID MapperFreeList (  VOID   )

Definition at line 1549 of file mapper.c. References ExFreePool(), _DEVICE_EXTENSION::FirmwareList, _FIRMWARE_CONFIGURATION::Identifier, MapperDeviceExtension, _FIRMWARE_CONFIGURATION::Next, PDEVICE_EXTENSION, PFIRMWARE_CONFIGURATION, and _FIRMWARE_CONFIGURATION::ResourceDescriptor. Referenced by IopInitializePlugPlayServices(), and MapperConstructRootEnumTree(). 01555 : 01556 01557 This routine walks through the list of firmware entries 01558 and frees all allocated memory. 01559 01560 Arguments: 01561 01562 None 01563 01564 Return Value: 01565 01566 None 01567 01568 --*/ 01569 01570 { 01571 PDEVICE_EXTENSION deviceExtension = &MapperDeviceExtension; 01572 PFIRMWARE_CONFIGURATION tempEntry; 01573 PFIRMWARE_CONFIGURATION firmwareEntry; 01574 01575 firmwareEntry = deviceExtension->FirmwareList; 01576 while (firmwareEntry) { 01577 01578 // 01579 // free allocated structures associated with the firmware entry 01580 // 01581 01582 if (firmwareEntry->ResourceDescriptor) { 01583 ExFreePool(firmwareEntry->ResourceDescriptor); 01584 } 01585 if (firmwareEntry->Identifier) { 01586 ExFreePool(firmwareEntry->Identifier); 01587 } 01588 01589 // 01590 // free this entry and move to the next 01591 // 01592 01593 tempEntry = firmwareEntry->Next; 01594 ExFreePool(firmwareEntry); 01595 firmwareEntry = tempEntry; 01596 } 01597 }

VOID MapperMarkKey (  IN HANDLE  Handle, IN PUNICODE_STRING  PathName, IN PFIRMWARE_CONFIGURATION  FirmwareEntry )

Definition at line 1091 of file mapper.c. References DebugPrint, ExAllocatePool, ExFreePool(), Handle, IopCmResourcesToIoResources(), L, MapperAdjustResourceList(), NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, RtlAppendUnicodeToString(), RtlInitUnicodeString(), and USHORT. Referenced by MapperConstructRootEnumTree(). 01099 : 01100 01101 Record in the root enum key that the firmware mapper found this entry. 01102 Migrate configuration information entries. 01103 01104 Arguments: 01105 01106 Handle - handle to the key 01107 PathName - base path name to this key 01108 FirmwareEntry - information from the firmware tree. 01109 01110 Return Value: 01111 01112 None 01113 01114 --*/ 01115 01116 { 01117 OBJECT_ATTRIBUTES objectAttributes; 01118 PCM_RESOURCE_LIST resourceList; 01119 UNICODE_STRING unicodeName; 01120 NTSTATUS status; 01121 HANDLE subKeyHandle; 01122 PWCHAR wcptr; 01123 ULONG disposition; 01124 ULONG buffer; 01125 USHORT originalLength; 01126 01127 // 01128 // Mark that this entry was in the firmware tree. 01129 // 01130 01131 buffer = 1; 01132 RtlInitUnicodeString(&unicodeName, REGSTR_VAL_FIRMWAREIDENTIFIED); 01133 01134 ZwSetValueKey(Handle, 01135 &unicodeName, 01136 0, 01137 REG_DWORD, 01138 &buffer, 01139 sizeof(ULONG)); 01140 01141 // 01142 // Create the control subkey 01143 // 01144 01145 DebugPrint((MAPPER_INFORMATION, 01146 "Mapper: marking existing key\n")); 01147 originalLength = PathName->Length; 01148 wcptr = (PWCHAR) ((PUCHAR)PathName->Buffer + PathName->Length); 01149 wcptr++; // locate eos 01150 01151 // 01152 // Build the volatile control key 01153 // 01154 01155 InitializeObjectAttributes(&objectAttributes, 01156 PathName, 01157 OBJ_CASE_INSENSITIVE, 01158 NULL, 01159 NULL); 01160 RtlAppendUnicodeToString(PathName, L"\\Control"); 01161 status = ZwCreateKey(&subKeyHandle, 01162 KEY_READ | KEY_WRITE, 01163 &objectAttributes, 01164 0, 01165 NULL, 01166 REG_OPTION_VOLATILE, 01167 &disposition); 01168 01169 if (NT_SUCCESS(status)) { 01170 01171 // 01172 // Create the found by firmware volatile. 01173 // 01174 01175 buffer = 1; 01176 RtlInitUnicodeString(&unicodeName, REGSTR_VAL_FIRMWAREMEMBER); 01177 01178 ZwSetValueKey(subKeyHandle, 01179 &unicodeName, 01180 0, 01181 REG_DWORD, 01182 &buffer, 01183 sizeof(ULONG)); 01184 ZwClose(subKeyHandle); 01185 01186 } else { 01187 01188 // 01189 // ignore failures 01190 // 01191 01192 DebugPrint((MAPPER_ERROR, 01193 "Mapper: failed to mark control key %x\n", 01194 status)); 01195 } 01196 01197 // 01198 // if there is a resource descriptor, restore path and open LogConf key. 01199 // 01200 01201 if (FirmwareEntry->ResourceDescriptor) { 01202 PathName->Length = originalLength; 01203 *wcptr = (WCHAR) 0; 01204 01205 InitializeObjectAttributes(&objectAttributes, 01206 PathName, 01207 OBJ_CASE_INSENSITIVE, 01208 NULL, 01209 NULL); 01210 RtlAppendUnicodeToString(PathName, L"\\LogConf"); 01211 status = ZwCreateKey(&subKeyHandle, 01212 KEY_READ | KEY_WRITE, 01213 &objectAttributes, 01214 0, 01215 NULL, 01216 REG_OPTION_VOLATILE, 01217 &disposition); 01218 01219 if (NT_SUCCESS(status)) { 01220 ULONG size; 01221 01222 // 01223 // two entries need to be made: 01224 // BootConfig:REG_RESOURCE_LIST 01225 // BasicConfigVector:REG_RESOURCE_REQUIREMENTS_LIST 01226 // 01227 01228 size = sizeof(CM_RESOURCE_LIST) - 01229 sizeof(CM_FULL_RESOURCE_DESCRIPTOR) + 01230 FirmwareEntry->ResourceDescriptorSize; 01231 01232 resourceList = ExAllocatePool(NonPagedPool, size); 01233 01234 if (resourceList) { 01235 PIO_RESOURCE_REQUIREMENTS_LIST reqList; 01236 01237 resourceList->Count = 1; 01238 RtlMoveMemory(&resourceList->List[0], 01239 FirmwareEntry->ResourceDescriptor, 01240 FirmwareEntry->ResourceDescriptorSize); 01241 01242 resourceList = MapperAdjustResourceList ( 01243 resourceList, 01244 FirmwareEntry->PnPId, 01245 &size 01246 ); 01247 01248 RtlInitUnicodeString(&unicodeName, 01249 L"BootConfig"); 01250 ZwSetValueKey(subKeyHandle, 01251 &unicodeName, 01252 0, 01253 REG_RESOURCE_LIST, 01254 resourceList, 01255 size); 01256 #if 0 01257 // 01258 // Now do the resource requirements list. 01259 // 01260 01261 reqList = IopCmResourcesToIoResources(0, resourceList); 01262 01263 if (reqList) { 01264 RtlInitUnicodeString(&unicodeName, 01265 L"BasicConfigVector"); 01266 ZwSetValueKey(subKeyHandle, 01267 &unicodeName, 01268 0, 01269 REG_RESOURCE_REQUIREMENTS_LIST, 01270 reqList, 01271 reqList->ListSize); 01272 ExFreePool(reqList); 01273 } 01274 #endif 01275 ExFreePool(resourceList); 01276 } 01277 } else { 01278 01279 // 01280 // ignore errors 01281 // 01282 01283 DebugPrint((MAPPER_ERROR, 01284 "Mapper: failed to update logconf key %x\n", 01285 status)); 01286 } 01287 } 01288 01289 // 01290 // Restore path passed in. 01291 // 01292 01293 PathName->Length = originalLength; 01294 *wcptr = (WCHAR) 0; 01295 }

NTSTATUS MapperPeripheralCallback (  IN PVOID  Context, IN PUNICODE_STRING  PathName, IN INTERFACE_TYPE  BusType, IN ULONG  BusNumber, IN PKEY_VALUE_FULL_INFORMATION *  BusInformation, IN CONFIGURATION_TYPE  ControllerType, IN ULONG  ControllerNumber, IN PKEY_VALUE_FULL_INFORMATION *  ControllerInformation, IN CONFIGURATION_TYPE  PeripheralType, IN ULONG  PeripheralNumber, IN PKEY_VALUE_FULL_INFORMATION *  PeripheralInformation )

Definition at line 535 of file mapper.c. References DebugPrint, ExAllocatePool, ExFreePool(), _FIRMWARE_CONFIGURATION::Identifier, _FIRMWARE_CONFIGURATION::IdentifierLength, _FIRMWARE_CONFIGURATION::IdentifierType, IoQueryDeviceIdentifier, MapperTranslatePnPId(), NonPagedPool, _FIRMWARE_CONFIGURATION::PeripheralNumber, _FIRMWARE_CONFIGURATION::PeripheralType, PeripheralType, PFIRMWARE_CONFIGURATION, and _FIRMWARE_CONFIGURATION::PnPId. Referenced by MapperCallback(). 00551 : 00552 00553 This routine is used to acquire firmware tree information about 00554 pointer devices in the system. 00555 00556 Arguments: 00557 00558 Context - Pointer to the device extension. 00559 PathName - unicode registry path. 00560 BusType - Internal, Isa, ... 00561 BusNumber - Which bus if we are on a multibus system. 00562 BusInformation - Configuration information about the bus. Not Used. 00563 ControllerType - serial or ata disk. 00564 ControllerNumber - Which controller if there is more than one 00565 controller in the system. 00566 ControllerInformation - Array of pointers to the three pieces of 00567 registry information. 00568 PeripheralType - Undefined for this call. 00569 PeripheralNumber - Undefined for this call. 00570 PeripheralInformation - Undefined for this call. 00571 00572 Return Value: 00573 00574 STATUS_SUCCESS if everything went ok, or STATUS_INSUFFICIENT_RESOURCES 00575 if it couldn't map the base csr or acquire the device object, or 00576 all of the resource information couldn't be acquired. 00577 00578 --*/ 00579 00580 { 00581 PFIRMWARE_CONFIGURATION firmwareEntry = Context; 00582 PKEY_VALUE_FULL_INFORMATION information; 00583 ULONG dataLength; 00584 PWCHAR ptr; 00585 PVOID temp; 00586 00587 DebugPrint((MAPPER_REGISTRY, 00588 "Mapper: peripheral registry location is\n %ws\n", 00589 PathName->Buffer)); 00590 00591 if (!ControllerInformation) { 00592 DebugPrint((MAPPER_VERBOSE, 00593 "Mapper: No component information\n")); 00594 } 00595 if (!PeripheralInformation) { 00596 DebugPrint((MAPPER_VERBOSE, 00597 "Mapper: No peripheral information\n")); 00598 return STATUS_SUCCESS; 00599 } 00600 00601 // 00602 // Map the PnP Id for this device. 00603 // 00604 00605 if (PeripheralInformation[IoQueryDeviceIdentifier]) { 00606 information = PeripheralInformation[IoQueryDeviceIdentifier]; 00607 firmwareEntry->PnPId = MapperTranslatePnPId(PeripheralType, information); 00608 00609 if (firmwareEntry->PnPId) { 00610 // 00611 // Remember the peripheral's identifier (if it has one, and it's a REG_SZ value) 00612 // for use as the default PnP device description. 00613 // 00614 00615 if (((dataLength = information->DataLength) > sizeof(WCHAR)) && 00616 (information->Type == REG_SZ)) { 00617 00618 ptr = (PWCHAR) ((PUCHAR)information + information->DataOffset); 00619 00620 if (*ptr) { 00621 temp = ExAllocatePool(NonPagedPool, dataLength); 00622 if (temp) { 00623 00624 // 00625 // If there's already an identifier here (from the peripheral's 00626 // controller) then wipe it out. 00627 // 00628 00629 if(firmwareEntry->Identifier) { 00630 ExFreePool(firmwareEntry->Identifier); 00631 } 00632 00633 // 00634 // Move the data 00635 // 00636 00637 firmwareEntry->Identifier = temp; 00638 firmwareEntry->IdentifierType = information->Type; 00639 firmwareEntry->IdentifierLength = dataLength; 00640 RtlMoveMemory(firmwareEntry->Identifier, ptr, dataLength); 00641 } 00642 } 00643 } 00644 } 00645 } 00646 00647 // 00648 // Save the ordinals for the peripheral type and number 00649 // 00650 00651 firmwareEntry->PeripheralType = PeripheralType; 00652 firmwareEntry->PeripheralNumber = PeripheralNumber; 00653 00654 return STATUS_SUCCESS; 00655 }

VOID MapperPhantomizeDetectedComPorts (  VOID   )

Definition at line 2060 of file mapper.c. References _FIRMWARE_CONFIGURATION::BusNumber, _FIRMWARE_CONFIGURATION::BusType, _FIRMWARE_CONFIGURATION::ControllerNumber, _FIRMWARE_CONFIGURATION::ControllerType, DebugPrint, ENUM_KEY_BUFFER_SIZE, ExAllocatePool, ExFreePool(), _DEVICE_EXTENSION::FirmwareList, INSTANCE_BUFFER_SIZE, L, MapperDeviceExtension, _FIRMWARE_CONFIGURATION::NewlyCreated, _FIRMWARE_CONFIGURATION::Next, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, PDEVICE_EXTENSION, _FIRMWARE_CONFIGURATION::PeripheralNumber, _FIRMWARE_CONFIGURATION::PeripheralType, PFIRMWARE_CONFIGURATION, _FIRMWARE_CONFIGURATION::PnPId, regValue(), RtlAppendUnicodeToString(), RtlInitUnicodeString(), and SerialController. Referenced by IopInitializePlugPlayServices(). : This routine turns all newly-created firmware/ntdetect COM ports into phantoms. Arguments: None Return Value: None --*/ { PFIRMWARE_CONFIGURATION firmwareEntry; NTSTATUS status; PWCHAR registryBase; PWCHAR instanceBuffer; HANDLE handle; PWCHAR buffer; PDEVICE_EXTENSION DeviceExtension = &MapperDeviceExtension; UNICODE_STRING enumKey; OBJECT_ATTRIBUTES objectAttributes; UNICODE_STRING unicodeName; ULONG regValue; // // allocate space needed for the registry path into the root // enumerator tree. Note, limited size on path length. // buffer = ExAllocatePool(NonPagedPool, ENUM_KEY_BUFFER_SIZE); if (!buffer) { DebugPrint((MAPPER_ERROR, "Mapper: could not allocate memory for registry update\n")); return; } instanceBuffer = ExAllocatePool(NonPagedPool, INSTANCE_BUFFER_SIZE); if (!instanceBuffer) { ExFreePool(buffer); DebugPrint((MAPPER_ERROR, "Mapper: could not allocate memory for instance buffer\n")); return; } InitializeObjectAttributes(&objectAttributes, &enumKey, OBJ_CASE_INSENSITIVE, NULL, NULL); #if UMODETEST registryBase = L"\\Registry\\Machine\\System\\TestControlSet\\Enum\\Root\\"; #else registryBase = L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\Root\\"; #endif firmwareEntry = DeviceExtension->FirmwareList; while (firmwareEntry) { // // Construct the base for the path for this entry. // if ((firmwareEntry->ControllerType == SerialController) && firmwareEntry->NewlyCreated) { RtlInitUnicodeString(&enumKey, NULL); enumKey.MaximumLength = ENUM_KEY_BUFFER_SIZE; enumKey.Buffer = buffer; RtlZeroMemory(buffer, ENUM_KEY_BUFFER_SIZE); RtlAppendUnicodeToString(&enumKey, registryBase); RtlAppendUnicodeToString(&enumKey, firmwareEntry->PnPId); // // Construct the instance name. // RtlZeroMemory(instanceBuffer, INSTANCE_BUFFER_SIZE); swprintf(instanceBuffer, L"\\%d_%d_%d_%d_%d_%d", firmwareEntry->BusType, firmwareEntry->BusNumber, firmwareEntry->ControllerType, firmwareEntry->ControllerNumber, firmwareEntry->PeripheralType, firmwareEntry->PeripheralNumber); RtlAppendUnicodeToString(&enumKey, instanceBuffer); status = ZwOpenKey(&handle, KEY_READ | KEY_WRITE, &objectAttributes ); if (NT_SUCCESS(status)) { RtlInitUnicodeString(&unicodeName, REGSTR_VAL_PHANTOM); regValue = 1; ZwSetValueKey(handle, &unicodeName, 0, REG_DWORD, &regValue, sizeof(regValue) ); ZwClose(handle); } } firmwareEntry = firmwareEntry->Next; } ExFreePool (buffer); ExFreePool (instanceBuffer); }

VOID MapperProcessFirmwareTree (  IN BOOLEAN  OnlyProcessSerialPorts  )

Definition at line 1009 of file mapper.c. References CONFIGURATION_TYPE, CONTROLLER_TYPES_COUNT, DebugPrint, DiskController, FloppyDiskPeripheral, IoQueryDeviceDescription(), KeyboardController, MapperCallback(), MapperDeviceExtension, NULL, ParallelController, PointerController, and SerialController. Referenced by IopInitializePlugPlayServices(). : Query the information in the firmware tree to know what system board devices were located. This will cause a FirmwareList to be created on the device extention passed. Arguments: OnlyProcessSerialPorts - if non-zero, then we'll only look at serial ports. This is done on ACPI machines where, in general, we don't want to pay attention to ntdetect/firmware information (but we have to for serial ports so that legacy add-in ISA serial ports and modems are detected automatically as in previous versions of NT as well as Win9x). Return Value: None --*/ { INTERFACE_TYPE interfaceType; ULONG index; CONFIGURATION_TYPE sc; CONFIGURATION_TYPE controllerTypes[] = { PointerController, KeyboardController, ParallelController, DiskController, FloppyDiskPeripheral, SerialController // must be last }; #define CONTROLLER_TYPES_COUNT (sizeof(controllerTypes) / sizeof(controllerTypes[0])) // // Locate all firmware controller information and save its resource usage. // // BUGBUG (lonnym)--it's pretty inefficient to be going through all // interface types, when we really only care about a very small subset of // non-PnP buses (e.g., ISA, EISA, maybe Internal). // for (interfaceType = 0; interfaceType < MaximumInterfaceType; interfaceType++) { DebugPrint((MAPPER_VERBOSE, "Mapper: searching on interface ===> %d\n", interfaceType)); if(OnlyProcessSerialPorts) { // // Start out at the last element of the array, so we only process // SerialControllers. // index = CONTROLLER_TYPES_COUNT - 1; } else { index = 0; } for ( ; index < CONTROLLER_TYPES_COUNT; index++) { sc = controllerTypes[index]; IoQueryDeviceDescription(&interfaceType, NULL, &sc, NULL, NULL, NULL, MapperCallback, &MapperDeviceExtension); } } }

VOID MapperSeedKey (  IN HANDLE  Handle, IN PUNICODE_STRING  PathName, IN PFIRMWARE_CONFIGURATION  FirmwareEntry, IN BOOLEAN  DeviceIsPhantom )

Definition at line 1298 of file mapper.c. References ASSERT, _KEY_SEED::Attribute, ComPortDBAdd(), DebugPrint, _MAPPER_SEED::DwordValueContent, ExAllocatePool, ExFreePool(), FALSE, Handle, IopOpenDeviceParametersSubkey(), KEY_SEED_DEVICE_PARAMETERS, KeyboardPeripheral, _KEY_SEED::KeyName, L, MapperKeySeed, MapperValueSeed, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, _MAPPER_SEED::Options, _KEY_SEED::Options, OPTIONS_INSERT_COMPATIBLE_IDS, OPTIONS_INSERT_DEVICEDESC, OPTIONS_INSERT_PHANTOM_MARKER, OPTIONS_INSERT_PNP_ID, ParallelController, PKEY_SEED, PMAPPER_SEED, PointerPeripheral, PS2_KEYBOARD_COMPATIBLE_ID, PS2_MOUSE_COMPATIBLE_ID, RtlAppendUnicodeToString(), RtlInitUnicodeString(), SEED_BUFFER_SIZE, SerialController, USHORT, _MAPPER_SEED::ValueName, and _MAPPER_SEED::ValueType. Referenced by MapperConstructRootEnumTree(). : This routine seeds a registry key with enough information to get PnP to run the class installer on the devnode. Arguments: Handle - handle to the key PathName - base path name to this key FirmwareEntry - information from the firmware tree DeviceIsPhantom - if non-zero, add "Phantom" value entry so the root enumerator will skip this device instance (i.e., not turn it into a devnode) Return Value: None --*/ { #define SEED_BUFFER_SIZE (512 * sizeof(WCHAR)) UNICODE_STRING unicodeName; UNICODE_STRING unicodeValue; OBJECT_ATTRIBUTES objectAttributes; PMAPPER_SEED valueSeed; PKEY_SEED keySeed; NTSTATUS status; HANDLE subKeyHandle; PWCHAR pnpid; PWCHAR buffer; PWCHAR wcptr; ULONG disposition; ULONG size; USHORT originalLength; buffer = ExAllocatePool(NonPagedPool, SEED_BUFFER_SIZE); if (!buffer) { return; } RtlZeroMemory(buffer, SEED_BUFFER_SIZE); // // Create subkeys. // originalLength = PathName->Length; wcptr = (PWCHAR) ((PUCHAR)PathName->Buffer + PathName->Length); for (keySeed = MapperKeySeed; keySeed->KeyName; keySeed++) { // // Reset the base path for the next key to seed. // *wcptr = (WCHAR) 0; PathName->Length = originalLength; RtlAppendUnicodeToString(PathName, keySeed->KeyName); // // Only build a device parameters key if there is something // to put in the key (i.e., this is a serial or parallel port). // if (keySeed->Options & KEY_SEED_DEVICE_PARAMETERS) { if (((FirmwareEntry->ControllerType != SerialController) && (FirmwareEntry->ControllerType != ParallelController)) || !FirmwareEntry->Identifier) { continue; } status = IopOpenDeviceParametersSubkey( &subKeyHandle, NULL, PathName, KEY_READ | KEY_WRITE ); if (NT_SUCCESS(status)) { status = STATUS_SUCCESS; } else { status = STATUS_UNSUCCESSFUL; } } else { // // need to construct this key. // InitializeObjectAttributes(&objectAttributes, PathName, OBJ_CASE_INSENSITIVE, NULL, NULL); status = ZwCreateKey(&subKeyHandle, KEY_READ | KEY_WRITE, &objectAttributes, 0, NULL, keySeed->Attribute, &disposition); } if (NT_SUCCESS(status)) { // // Check to see if this is the parameters key and // migrate the parameter information. // if (keySeed->Options & KEY_SEED_DEVICE_PARAMETERS) { if (FirmwareEntry->ControllerType == SerialController) { ComPortDBAdd(subKeyHandle, (PWSTR)FirmwareEntry->Identifier); } else { // // to get here there must be identifier information // in the FirmwareEntry, so that check is not performed. // // NOTE: this will only happen once - when the key is // created -- perhaps this needs to happen on every // boot. // RtlInitUnicodeString(&unicodeName, L"PortName"); ZwSetValueKey(subKeyHandle, &unicodeName, 0, FirmwareEntry->IdentifierType, FirmwareEntry->Identifier, FirmwareEntry->IdentifierLength); } } ZwClose(subKeyHandle); } else { // // ignore failures // DebugPrint((MAPPER_ERROR, "Mapper: failed to build control key %x\n", status)); } } // // Undo the mangling of the path name performed in the loop above. // *wcptr = (WCHAR) 0; PathName->Length = originalLength; // // Create values. // pnpid = FirmwareEntry->PnPId; for (valueSeed = MapperValueSeed; valueSeed->ValueName; valueSeed++) { if (valueSeed->ValueType == REG_DWORD) { if ((valueSeed->Options == OPTIONS_INSERT_PHANTOM_MARKER) && !DeviceIsPhantom) { // // Device isn't a phantom--we don't want to mark it as such. // continue; } size = sizeof(ULONG); RtlMoveMemory(buffer, &valueSeed->DwordValueContent, size); } else if (valueSeed->Options == OPTIONS_INSERT_PNP_ID) { size = (wcslen(pnpid) + 2) * sizeof(WCHAR); // eos multi_sz if (FirmwareEntry->BusType == Eisa) { // // need a mult_sz of EISA\PNPblah *PNPblah // RtlZeroMemory(buffer, SEED_BUFFER_SIZE); wcptr = pnpid; wcptr++; swprintf(buffer, L"EISA\\%s", wcptr); wcptr = buffer; while (*wcptr) { wcptr++; } wcptr++; // step past eos for 1st string RtlMoveMemory(wcptr, pnpid, size); size += (ULONG)((PUCHAR)wcptr - (PUCHAR)buffer); } else { RtlMoveMemory(buffer, pnpid, size - sizeof(WCHAR)); buffer[size / sizeof(WCHAR) - 1] = L'\0'; } } else if (valueSeed->Options == OPTIONS_INSERT_COMPATIBLE_IDS) { if (FirmwareEntry->PeripheralType == KeyboardPeripheral) { size = sizeof(PS2_KEYBOARD_COMPATIBLE_ID); RtlMoveMemory(buffer, PS2_KEYBOARD_COMPATIBLE_ID, size); } else if (FirmwareEntry->PeripheralType == PointerPeripheral && (wcscmp(pnpid, L"*PNP0F0E") == 0 || wcscmp(pnpid, L"*PNP0F03") == 0 || wcscmp(pnpid, L"*PNP0F12") == 0)) { size = sizeof(PS2_MOUSE_COMPATIBLE_ID); RtlMoveMemory(buffer, PS2_MOUSE_COMPATIBLE_ID, size); } else { continue; } buffer[size / 2] = L'\0'; // 2nd NUL for MULTI_SZ size += sizeof(L'\0'); } else if (valueSeed->Options == OPTIONS_INSERT_DEVICEDESC) { size = FirmwareEntry->IdentifierLength; RtlMoveMemory(buffer, FirmwareEntry->Identifier, size); } else { DebugPrint((MAPPER_ERROR, "Mapper: NO VALUE TYPE!\n")); ASSERT(FALSE); continue; } RtlInitUnicodeString(&unicodeName, valueSeed->ValueName); ZwSetValueKey(Handle, &unicodeName, 0, valueSeed->ValueType, buffer, size); } ExFreePool(buffer); }

PWSTR MapperTranslatePnPId (  CONFIGURATION_TYPE  PeripheralType, PKEY_VALUE_FULL_INFORMATION  Identifier )

Definition at line 402 of file mapper.c. References DebugPrint, DiskController, DiskPeripheral, FloppyDiskPeripheral, FloppyId, KeyboardController, KeyboardMap, KeyboardPeripheral, MapperFindIdentMatch(), NULL, ParallelController, ParallelId, PeripheralType, PFIRMWARE_IDENT_TO_PNP_ID, _FIRMWARE_IDENT_TO_PNP_ID::PnPId, PointerController, PointerMap, PointerPeripheral, SerialController, and SerialId. Referenced by MapperCallback(), and MapperPeripheralCallback(). : Given the peripheral type and a location in the firmware tree this routine will determine the PnP Id to be used when constructing the root enumeration portion of the registry. Arguments: PeripheralType - the type of item being translated (keyboard, mouse, etc) PathName - the registry path name into the firmware tree for this device. Return Value: A pointer to the PnP Id string if a map is found. --*/ { PFIRMWARE_IDENT_TO_PNP_ID identMap; PWSTR identifierString; PWSTR idStr; if (Identifier) { identifierString = (PWSTR)((PUCHAR)Identifier + Identifier->DataOffset); DebugPrint((MAPPER_PNP_ID, "Mapper: identifier = %ws\n\tType = ", identifierString)); } idStr = NULL; switch (PeripheralType) { case DiskController: DebugPrint((MAPPER_PNP_ID, "%s (%d)\n", "DiskController", PeripheralType)); idStr = FloppyId; break; case SerialController: DebugPrint((MAPPER_PNP_ID, "%s (%d)\n", "SerialController", PeripheralType)); idStr = SerialId; break; case ParallelController: DebugPrint((MAPPER_PNP_ID, "%s (%d)\n", "ParallelController", PeripheralType)); idStr = ParallelId; break; case PointerController: DebugPrint((MAPPER_PNP_ID, "%s (%d)\n", "PointerController", PeripheralType)); idStr = PointerMap[0].PnPId; break; case KeyboardController: DebugPrint((MAPPER_PNP_ID, "%s (%d)\n", "KeyboardController", PeripheralType)); idStr = KeyboardMap[0].PnPId; break; case DiskPeripheral: DebugPrint((MAPPER_PNP_ID, "%s (%d)\n", "DiskPeripheral", PeripheralType)); break; case FloppyDiskPeripheral: DebugPrint((MAPPER_PNP_ID, "%s (%d)\n", "FloppyDiskPeripheral", PeripheralType)); idStr = FloppyId; break; case PointerPeripheral: identMap = MapperFindIdentMatch(PointerMap, identifierString); if (identMap) { DebugPrint((MAPPER_PNP_ID, "%ws\n", identMap->PnPId)); idStr = identMap->PnPId; } else { DebugPrint((MAPPER_ERROR, "Mapper: No pointer match found\n")); } break; case KeyboardPeripheral: identMap = MapperFindIdentMatch(KeyboardMap, identifierString); if (identMap) { DebugPrint((MAPPER_PNP_ID, "%ws\n", identMap->PnPId)); idStr = identMap->PnPId; } else { DebugPrint((MAPPER_ERROR, "Mapper: No keyboard match found\n")); } break; default: DebugPrint((MAPPER_ERROR, "Mapper: Unknown device (%d)\n", PeripheralType)); break; } return idStr; }

---

Variable Documentation

PWSTR ATAId = L"*PNP0600"

Definition at line 238 of file mapper.c.

PWSTR FloppyId = L"*PNP0700"

Definition at line 231 of file mapper.c. Referenced by MapperAdjustResourceList(), and MapperTranslatePnPId().

FIRMWARE_IDENT_TO_PNP_ID KeyboardMap[]

Initial value: { L"XT_83KEY", L"*PNP0300", L"PCAT_86KEY", L"*PNP0301", L"PCXT_84KEY", L"*PNP0302", L"XT_84KEY", L"*PNP0302", L"101-KEY", L"*PNP0303", L"OLI_83KEY", L"*PNP0304", L"ATT_301", L"*PNP0304", L"OLI_102KEY", L"*PNP0305", L"OLI_86KEY", L"*PNP0306", L"OLI_A101_102KEY", L"*PNP0309", L"ATT_302", L"*PNP030a", L"PCAT_ENHANCED", L"*PNP030b", L"PC98_106KEY", L"*nEC1300", L"PC98_LaptopKEY", L"*nEC1300", L"PC98_N106KEY", L"*PNP0303", NULL, NULL } Definition at line 129 of file mapper.c. Referenced by MapperTranslatePnPId().

DEVICE_EXTENSION MapperDeviceExtension

Definition at line 122 of file mapper.c. Referenced by MapperConstructRootEnumTree(), MapperFreeList(), MapperPhantomizeDetectedComPorts(), and MapperProcessFirmwareTree().

KEY_SEED MapperKeySeed[]

Initial value: { L"\\Control", REG_OPTION_VOLATILE, KEY_SEED_REQUIRED, L"\\LogConf", REG_OPTION_NON_VOLATILE, KEY_SEED_REQUIRED, L"", REG_OPTION_NON_VOLATILE, KEY_SEED_DEVICE_PARAMETERS, NULL, 0, 0 } Definition at line 194 of file mapper.c. Referenced by MapperSeedKey().

MAPPER_SEED MapperValueSeed[]

Initial value: { REGSTR_VAL_HARDWAREID, REG_MULTI_SZ, 0, OPTIONS_INSERT_PNP_ID, REGSTR_VAL_COMPATIBLEIDS, REG_MULTI_SZ, 0, OPTIONS_INSERT_COMPATIBLE_IDS, REGSTR_VAL_FIRMWAREIDENTIFIED, REG_DWORD, 1, OPTIONS_NONE, REGSTR_VAL_DEVDESC, REG_SZ, 0, OPTIONS_INSERT_DEVICEDESC, REGSTR_VAL_PHANTOM, REG_DWORD, 1, OPTIONS_INSERT_PHANTOM_MARKER, NULL, 0, 0, 0 } Definition at line 176 of file mapper.c. Referenced by MapperSeedKey().

PWSTR ParallelId = L"*PNP0400"

Definition at line 223 of file mapper.c. Referenced by MapperTranslatePnPId().

PWSTR ParallelIdNEC = L"*nEC1401"

Definition at line 225 of file mapper.c. Referenced by MapperCallback().

FIRMWARE_IDENT_TO_PNP_ID PointerMap[]

Initial value: { L"PS2 MOUSE", L"*PNP0F0E", L"SERIAL MOUSE", L"*PNP0F0C", L"MICROSOFT PS2 MOUSE", L"*PNP0F03", L"LOGITECH PS2 MOUSE", L"*PNP0F12", L"MICROSOFT INPORT MOUSE", L"*PNP0F02", L"MICROSOFT SERIAL MOUSE", L"*PNP0F01", L"MICROSOFT BALLPOINT SERIAL MOUSE", L"*PNP0F09", L"LOGITECH SERIAL MOUSE", L"*PNP0F08", L"MICROSOFT BUS MOUSE", L"*PNP0F00", L"NEC PC-9800 BUS MOUSE", L"*nEC1F00", NULL, NULL } Definition at line 156 of file mapper.c. Referenced by MapperTranslatePnPId().

PWSTR SerialId = L"*PNP0501"

Definition at line 206 of file mapper.c. Referenced by MapperTranslatePnPId(), and UdfSerial32().

PWSTR SerialIdNEC[]

Initial value: { L"*nEC1500", L"*nEC1501", L"*nEC1502", L"*nEC1503", L"*nEC8071", L"*nEC0C01", NULL } Definition at line 208 of file mapper.c. Referenced by MapperCallback().

---