You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2422 lines
61 KiB
2422 lines
61 KiB
/*++
|
|
|
|
Copyright (c) 1991-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
misc.c
|
|
|
|
Abstract:
|
|
|
|
This file contains pnp isa bus extender support routines.
|
|
|
|
Author:
|
|
|
|
Shie-Lin Tzong (shielint) 27-July-1995
|
|
|
|
Environment:
|
|
|
|
Kernel mode only.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
#include "busp.h"
|
|
#include "pnpisa.h"
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
//#pragma alloc_text(PAGE, PipLockDeviceDatabase)
|
|
//#pragma alloc_text(PAGE, PipUnlockDeviceDatabase)
|
|
#pragma alloc_text(PAGE, PipQueryDeviceRelations)
|
|
//#pragma alloc_text(PAGE, PipIsCardEnumeratedAlready)
|
|
#pragma alloc_text(PAGE, PipCleanupAcquiredResources)
|
|
#pragma alloc_text(PAGE, PipMapReadDataPort)
|
|
#pragma alloc_text(PAGE, PipGetMappedAddress)
|
|
#pragma alloc_text(PAGE, PipDecompressEisaId)
|
|
#pragma alloc_text(PAGE, PipLogError)
|
|
#pragma alloc_text(PAGE, PipOpenRegistryKey)
|
|
#pragma alloc_text(PAGE, PipGetRegistryValue)
|
|
#pragma alloc_text(PAGE, PipOpenCurrentHwProfileDeviceInstanceKey)
|
|
#pragma alloc_text(PAGE, PipGetDeviceInstanceCsConfigFlags)
|
|
#pragma alloc_text(PAGE, PipDetermineResourceListSize)
|
|
#pragma alloc_text(PAGE, PipResetGlobals)
|
|
#pragma alloc_text(PAGE, PipMapAddressAndCmdPort)
|
|
#pragma alloc_text(PAGE, PiNeedDeferISABridge)
|
|
#pragma alloc_text(PAGE, PipReleaseDeviceResources)
|
|
#if DBG
|
|
//#pragma alloc_text(PAGE, PipDebugPrint)
|
|
#pragma alloc_text(PAGE, PipDumpIoResourceDescriptor)
|
|
#pragma alloc_text(PAGE, PipDumpIoResourceList)
|
|
#pragma alloc_text(PAGE, PipDumpCmResourceDescriptor)
|
|
#pragma alloc_text(PAGE, PipDumpCmResourceList)
|
|
#endif
|
|
#endif
|
|
|
|
#define IRQFLAGS_VALUE_NAME L"IrqFlags"
|
|
#define BOOTRESOURCES_VALUE_NAME L"BootRes"
|
|
|
|
#if ISOLATE_CARDS
|
|
|
|
UCHAR CurrentCsn = 0;
|
|
UCHAR CurrentDev = 255;
|
|
|
|
VOID
|
|
PipWaitForKey(VOID)
|
|
{
|
|
ASSERT((PipState == PiSConfig) || (PipState == PiSIsolation) || (PipState == PiSSleep));
|
|
PipWriteAddress(CONFIG_CONTROL_PORT);
|
|
PipWriteData(CONTROL_WAIT_FOR_KEY);
|
|
PipReportStateChange(PiSWaitForKey);
|
|
CurrentCsn = 0;
|
|
CurrentDev = 255;
|
|
}
|
|
|
|
VOID
|
|
PipConfig(
|
|
IN UCHAR Csn
|
|
)
|
|
{
|
|
ASSERT(Csn);
|
|
ASSERT((PipState == PiSConfig) || (PipState == PiSIsolation) || (PipState == PiSSleep));
|
|
PipWriteAddress(WAKE_CSN_PORT);
|
|
PipWriteData(Csn);
|
|
DebugPrint((DEBUG_STATE, "Wake CSN %u\n", (ULONG) Csn));
|
|
CurrentCsn = Csn;
|
|
CurrentDev = 255;
|
|
PipReportStateChange(PiSConfig);
|
|
}
|
|
|
|
VOID
|
|
PipIsolation(
|
|
VOID
|
|
)
|
|
{
|
|
ASSERT((PipState == PiSConfig) || (PipState == PiSIsolation) || (PipState == PiSSleep));
|
|
PipWriteAddress(WAKE_CSN_PORT);
|
|
PipWriteData(0);
|
|
CurrentCsn = 0;
|
|
CurrentDev = 255;
|
|
DebugPrint((DEBUG_STATE, "Isolate cards w/o CSN\n"));
|
|
PipReportStateChange(PiSIsolation);
|
|
}
|
|
VOID
|
|
PipSleep(
|
|
VOID
|
|
)
|
|
{
|
|
ASSERT((PipState == PiSConfig) || PipState == PiSIsolation);
|
|
PipWriteAddress(WAKE_CSN_PORT);
|
|
PipWriteData(0);
|
|
CurrentCsn = 0;
|
|
CurrentDev = 255;
|
|
DebugPrint((DEBUG_STATE, "Putting all cards to sleep (we think)\n"));
|
|
PipReportStateChange(PiSSleep);
|
|
}
|
|
|
|
VOID
|
|
PipActivateDevice (
|
|
)
|
|
{
|
|
UCHAR tmp;
|
|
|
|
PipWriteAddress(IO_RANGE_CHECK_PORT);
|
|
tmp = PipReadData();
|
|
tmp &= ~2;
|
|
PipWriteAddress(IO_RANGE_CHECK_PORT);
|
|
PipWriteData(tmp);
|
|
PipWriteAddress(ACTIVATE_PORT);
|
|
PipWriteData(1);
|
|
|
|
DebugPrint((DEBUG_STATE, "Activated card CSN %d/LDN %d\n",
|
|
(ULONG) CurrentCsn,
|
|
(ULONG) CurrentDev));
|
|
}
|
|
VOID
|
|
PipDeactivateDevice (
|
|
)
|
|
{
|
|
PipWriteAddress(ACTIVATE_PORT);
|
|
PipWriteData(0);
|
|
|
|
DebugPrint((DEBUG_STATE, "Deactivated card CSN %d/LDN %d\n",
|
|
(ULONG) CurrentCsn,
|
|
(ULONG) CurrentDev));
|
|
}
|
|
|
|
VOID
|
|
PipSelectDevice(
|
|
IN UCHAR Device
|
|
)
|
|
{
|
|
ASSERT(PipState == PiSConfig);
|
|
PipWriteAddress(LOGICAL_DEVICE_PORT);
|
|
PipWriteData(Device);
|
|
|
|
CurrentDev = Device;
|
|
DebugPrint((DEBUG_STATE, "Selected CSN %d/LDN %d\n",
|
|
(ULONG) CurrentCsn,
|
|
(ULONG) Device));
|
|
}
|
|
|
|
VOID
|
|
PipWakeAndSelectDevice(
|
|
IN UCHAR Csn,
|
|
IN UCHAR Device
|
|
)
|
|
{
|
|
PipLFSRInitiation();
|
|
PipConfig(Csn);
|
|
PipSelectDevice(Device);
|
|
}
|
|
|
|
PDEVICE_INFORMATION
|
|
PipReferenceDeviceInformation (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN BOOLEAN ConfigHardware
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function locks a device node so it won't go away.
|
|
|
|
Note, this function does not lock the whole device node tree.
|
|
|
|
Arguments:
|
|
|
|
DeviceNode - Supplies a pointer to the device information node
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDEVICE_INFORMATION deviceInfo;
|
|
|
|
deviceInfo = (PDEVICE_INFORMATION)DeviceObject->DeviceExtension;
|
|
if (deviceInfo && !(deviceInfo->Flags & DF_DELETED)) {
|
|
|
|
if ((deviceInfo->Flags & DF_NOT_FUNCTIONING) && ConfigHardware) {
|
|
PipDereferenceDeviceInformation(NULL, FALSE);
|
|
return NULL;
|
|
}
|
|
|
|
if (!(deviceInfo->Flags & DF_READ_DATA_PORT) && ConfigHardware) {
|
|
PipWakeAndSelectDevice(
|
|
deviceInfo->CardInformation->CardSelectNumber,
|
|
deviceInfo->LogicalDeviceNumber);
|
|
}
|
|
|
|
return deviceInfo;
|
|
} else {
|
|
PipDereferenceDeviceInformation(NULL, FALSE);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PipDereferenceDeviceInformation(
|
|
IN PDEVICE_INFORMATION DeviceInformation, BOOLEAN ConfigedHardware
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function releases the enumeration lock of the specified device node.
|
|
|
|
Arguments:
|
|
|
|
DeviceNode - Supplies a pointer to the device node whose lock is to be released.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
//
|
|
// Synchronize the dec and set event operations with IopAcquireEnumerationLock.
|
|
//
|
|
|
|
if (DeviceInformation) {
|
|
|
|
|
|
if (!(DeviceInformation->Flags & DF_READ_DATA_PORT) && ConfigedHardware) {
|
|
if (PipState != PiSWaitForKey) {
|
|
PipWaitForKey();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PipLockDeviceDatabase(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function locks the whole device node tree. Currently, eject operation
|
|
needs to lock the whole device node tree.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
KeWaitForSingleObject( &PipDeviceTreeLock,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
}
|
|
|
|
VOID
|
|
PipUnlockDeviceDatabase (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function releases the lock of the whole device node tree.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
KeSetEvent( &PipDeviceTreeLock,
|
|
0,
|
|
FALSE );
|
|
}
|
|
|
|
VOID
|
|
PipDeleteDevice (
|
|
PDEVICE_OBJECT DeviceObject
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine
|
|
|
|
Parameters:
|
|
|
|
P1 -
|
|
|
|
Return Value:
|
|
|
|
Status code that indicates whether or not the function was successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDEVICE_INFORMATION deviceInfo, devicex, devicep;
|
|
PCARD_INFORMATION cardInfo, cardx, cardp;
|
|
PSINGLE_LIST_ENTRY deviceLink, cardLink;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
deviceInfo = (PDEVICE_INFORMATION)DeviceObject->DeviceExtension;
|
|
|
|
deviceInfo->Flags |= DF_DELETED;
|
|
|
|
//
|
|
// Free the pool
|
|
//
|
|
|
|
if (deviceInfo->ResourceRequirements) {
|
|
ExFreePool(deviceInfo->ResourceRequirements);
|
|
deviceInfo->ResourceRequirements = NULL;
|
|
}
|
|
|
|
if (deviceInfo->BootResources) {
|
|
ExFreePool(deviceInfo->BootResources);
|
|
deviceInfo->BootResources = NULL;
|
|
}
|
|
|
|
if (deviceInfo->AllocatedResources) {
|
|
ExFreePool(deviceInfo->AllocatedResources);
|
|
deviceInfo->AllocatedResources = NULL;
|
|
}
|
|
|
|
if (deviceInfo->LogConfHandle) {
|
|
ZwClose(deviceInfo->LogConfHandle);
|
|
deviceInfo->LogConfHandle = NULL;
|
|
}
|
|
|
|
busExtension = deviceInfo->ParentDeviceExtension;
|
|
cardInfo = deviceInfo->CardInformation;
|
|
|
|
PipLockDeviceDatabase();
|
|
|
|
//
|
|
// Remove the device from device list.
|
|
//
|
|
|
|
deviceLink = busExtension->DeviceList.Next;
|
|
devicep = NULL;
|
|
devicex = NULL;
|
|
while (deviceLink) {
|
|
devicex = CONTAINING_RECORD (deviceLink, DEVICE_INFORMATION, DeviceList);
|
|
if (devicex == deviceInfo) {
|
|
break;
|
|
}
|
|
devicep = devicex;
|
|
deviceLink = devicex->DeviceList.Next;
|
|
}
|
|
ASSERT(devicex == deviceInfo);
|
|
if (devicep == NULL) {
|
|
busExtension->DeviceList.Next = deviceInfo->DeviceList.Next;
|
|
} else {
|
|
devicep->DeviceList.Next = deviceInfo->DeviceList.Next;
|
|
}
|
|
|
|
//
|
|
// Remove the device from logical device list of the card
|
|
//
|
|
|
|
deviceLink = cardInfo->LogicalDeviceList.Next;
|
|
devicep = NULL;
|
|
devicex = NULL;
|
|
while (deviceLink) {
|
|
devicex = CONTAINING_RECORD (deviceLink, DEVICE_INFORMATION, LogicalDeviceList);
|
|
if (devicex == deviceInfo) {
|
|
break;
|
|
}
|
|
devicep = devicex;
|
|
deviceLink = devicex->LogicalDeviceList.Next;
|
|
}
|
|
ASSERT(devicex == deviceInfo);
|
|
if (devicep == NULL) {
|
|
cardInfo->LogicalDeviceList.Next = deviceInfo->LogicalDeviceList.Next;
|
|
} else {
|
|
devicep->LogicalDeviceList.Next = deviceInfo->LogicalDeviceList.Next;
|
|
}
|
|
|
|
cardInfo->NumberLogicalDevices--;
|
|
|
|
//
|
|
// All the devices are gone. That means the card is removed.
|
|
// Next remove the isapnp card structure.
|
|
//
|
|
|
|
if (cardInfo->NumberLogicalDevices == 0) {
|
|
ASSERT(cardInfo->LogicalDeviceList.Next == NULL);
|
|
cardLink = busExtension->CardList.Next;
|
|
cardp = NULL;
|
|
cardx = NULL;
|
|
while (cardLink) {
|
|
cardx = CONTAINING_RECORD (cardLink, CARD_INFORMATION, CardList);
|
|
if (cardx == cardInfo) {
|
|
break;
|
|
}
|
|
cardp = cardx;
|
|
cardLink = cardx->CardList.Next;
|
|
}
|
|
ASSERT(cardx == cardInfo);
|
|
if (cardp == NULL) {
|
|
busExtension->CardList.Next = cardInfo->CardList.Next;
|
|
} else {
|
|
cardp->CardList.Next = cardInfo->CardList.Next;
|
|
}
|
|
}
|
|
|
|
PipUnlockDeviceDatabase();
|
|
|
|
//
|
|
// Remove the card information structure after releasing spin lock.
|
|
//
|
|
|
|
if (cardInfo->NumberLogicalDevices == 0) {
|
|
if (cardInfo->CardData) {
|
|
ExFreePool(cardInfo->CardData);
|
|
}
|
|
ExFreePool(cardInfo);
|
|
deviceInfo->CardInformation = NULL;
|
|
}
|
|
|
|
IoDeleteDevice(DeviceObject);
|
|
}
|
|
|
|
NTSTATUS
|
|
PipQueryDeviceRelations (
|
|
PPI_BUS_EXTENSION BusExtension,
|
|
PDEVICE_RELATIONS *DeviceRelations,
|
|
BOOLEAN Removal
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine
|
|
|
|
Parameters:
|
|
|
|
P1 -
|
|
|
|
Return Value:
|
|
|
|
Status code that indicates whether or not the function was successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDEVICE_INFORMATION deviceInfo;
|
|
PSINGLE_LIST_ENTRY deviceLink;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PDEVICE_OBJECT *devicePtr;
|
|
ULONG count = 0;
|
|
PDEVICE_RELATIONS deviceRelations;
|
|
|
|
PAGED_CODE();
|
|
|
|
*DeviceRelations = NULL;
|
|
|
|
//
|
|
// Go through the card link list to match the card data
|
|
//
|
|
|
|
deviceLink = BusExtension->DeviceList.Next;
|
|
while (deviceLink) {
|
|
deviceInfo = CONTAINING_RECORD (deviceLink, DEVICE_INFORMATION, DeviceList);
|
|
//
|
|
// if it's the RDP ignore it for removal relations
|
|
//
|
|
if ((deviceInfo->Flags & DF_ENUMERATED) &&
|
|
(!(deviceInfo->Flags & DF_READ_DATA_PORT) || !Removal)) {
|
|
count++;
|
|
} else {
|
|
|
|
DebugPrint((DEBUG_PNP, "PipQueryDeviceRelations skipping a node, Flags: %x\n",deviceInfo->Flags));
|
|
}
|
|
deviceLink = deviceInfo->DeviceList.Next;
|
|
}
|
|
if (count != 0) {
|
|
deviceRelations = (PDEVICE_RELATIONS) ExAllocatePool(
|
|
PagedPool,
|
|
sizeof(DEVICE_RELATIONS) + (count - 1) * sizeof(PDEVICE_OBJECT));
|
|
if (deviceRelations) {
|
|
deviceRelations->Count = count;
|
|
deviceLink = BusExtension->DeviceList.Next;
|
|
devicePtr = deviceRelations->Objects;
|
|
while (deviceLink) {
|
|
deviceInfo = CONTAINING_RECORD (deviceLink, DEVICE_INFORMATION, DeviceList);
|
|
|
|
if ((deviceInfo->Flags & DF_ENUMERATED) &&
|
|
(!(deviceInfo->Flags & DF_READ_DATA_PORT) || !(Removal))) {
|
|
ObReferenceObject(deviceInfo->PhysicalDeviceObject);
|
|
*devicePtr = deviceInfo->PhysicalDeviceObject;
|
|
devicePtr++;
|
|
}
|
|
deviceLink = deviceInfo->DeviceList.Next;
|
|
}
|
|
*DeviceRelations = deviceRelations;
|
|
} else {
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
PCARD_INFORMATION
|
|
PipIsCardEnumeratedAlready(
|
|
IN PPI_BUS_EXTENSION BusExtension,
|
|
IN PUCHAR CardData,
|
|
IN ULONG DataLength
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine finds the card information structure which contains the same CardData.
|
|
|
|
Parameters:
|
|
|
|
CardData - Supplies a pointer to the CardData
|
|
|
|
DataLength - The length of the CardData
|
|
|
|
Return Value:
|
|
|
|
A pointer to the CARD_INFORMATION structure if found.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCARD_INFORMATION cardInfo;
|
|
PSINGLE_LIST_ENTRY cardLink;
|
|
PSERIAL_IDENTIFIER serialId1, serialId2 = (PSERIAL_IDENTIFIER)CardData;
|
|
|
|
//
|
|
// Go through the card link list to match the card data
|
|
//
|
|
|
|
cardLink = BusExtension->CardList.Next;
|
|
while (cardLink) {
|
|
cardInfo = CONTAINING_RECORD (cardLink, CARD_INFORMATION, CardList);
|
|
if (cardInfo->CardSelectNumber != 0) { // if == 0, card is no longer present
|
|
serialId1 = (PSERIAL_IDENTIFIER)cardInfo->CardData;
|
|
ASSERT(serialId1 && serialId2);
|
|
if (serialId1->VenderId == serialId2->VenderId &&
|
|
serialId1->SerialNumber == serialId2->SerialNumber) {
|
|
return cardInfo;
|
|
}
|
|
}
|
|
cardLink = cardInfo->CardList.Next; // Get the next addr before releasing pool
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
VOID
|
|
PipCleanupAcquiredResources (
|
|
PPI_BUS_EXTENSION BusExtension
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine cleans up the resources assigned to the readdata, command and address
|
|
ports.
|
|
|
|
Parameters:
|
|
|
|
BusExtension - specifies the isapnp bus to be cleaned up.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Release address, command and read data port resources.
|
|
//
|
|
|
|
if (BusExtension->CommandPort && BusExtension->CmdPortMapped) {
|
|
MmUnmapIoSpace(BusExtension->CommandPort, 1);
|
|
BusExtension->CmdPortMapped = FALSE;
|
|
}
|
|
BusExtension->CommandPort = NULL;
|
|
|
|
if (BusExtension->AddressPort && BusExtension->AddrPortMapped) {
|
|
MmUnmapIoSpace(BusExtension->AddressPort, 1);
|
|
BusExtension->AddrPortMapped = FALSE;
|
|
}
|
|
BusExtension->AddressPort = NULL;
|
|
|
|
if (BusExtension->ReadDataPort) {
|
|
PipReadDataPort = PipCommandPort = PipAddressPort = NULL;
|
|
}
|
|
if (BusExtension->ReadDataPort && BusExtension->DataPortMapped) {
|
|
MmUnmapIoSpace(BusExtension->ReadDataPort - 3, 4);
|
|
BusExtension->DataPortMapped = FALSE;
|
|
}
|
|
BusExtension->ReadDataPort = NULL;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipMapReadDataPort (
|
|
IN PPI_BUS_EXTENSION BusExtension,
|
|
IN PHYSICAL_ADDRESS Start,
|
|
IN ULONG Length
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine maps specified port resources.
|
|
|
|
Arguments:
|
|
|
|
BusExtension - Supplies a pointer to the pnp bus extension.
|
|
|
|
BaseAddressLow,
|
|
BaseAddressHi - Supplies the read data port base address range to be mapped.
|
|
Return Value:
|
|
|
|
NTSTATUS code.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
ULONG size;
|
|
PHYSICAL_ADDRESS physicalAddress;
|
|
ULONG dumpData[3];
|
|
BOOLEAN conflictDetected;
|
|
|
|
PAGED_CODE();
|
|
|
|
if (BusExtension->ReadDataPort && BusExtension->DataPortMapped) {
|
|
MmUnmapIoSpace(PipReadDataPort - 3, 4);
|
|
PipReadDataPort = BusExtension->ReadDataPort = NULL;
|
|
BusExtension->DataPortMapped = FALSE;
|
|
}
|
|
|
|
PipReadDataPort = PipGetMappedAddress(
|
|
Isa, // InterfaceType
|
|
0, // BusNumber,
|
|
Start,
|
|
Length,
|
|
CM_RESOURCE_PORT_IO,
|
|
&BusExtension->DataPortMapped
|
|
);
|
|
|
|
DebugPrint((DEBUG_RDP, "PnpIsa:ReadDataPort is at %x\n",PipReadDataPort+3));
|
|
if (PipReadDataPort) {
|
|
PipReadDataPort += 3;
|
|
BusExtension->ReadDataPort = PipReadDataPort;
|
|
status = STATUS_SUCCESS;
|
|
} else {
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
PVOID
|
|
PipGetMappedAddress(
|
|
IN INTERFACE_TYPE BusType,
|
|
IN ULONG BusNumber,
|
|
IN PHYSICAL_ADDRESS IoAddress,
|
|
IN ULONG NumberOfBytes,
|
|
IN ULONG AddressSpace,
|
|
OUT PBOOLEAN MappedAddress
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine maps an IO address to system address space.
|
|
|
|
Arguments:
|
|
|
|
BusType - Supplies the type of bus - eisa, mca, isa...
|
|
|
|
IoBusNumber - Supplies the bus number.
|
|
|
|
IoAddress - Supplies the base device address to be mapped.
|
|
|
|
NumberOfBytes - Supplies the number of bytes for which the address is
|
|
valid.
|
|
|
|
AddressSpace - Supplies whether the address is in io space or memory.
|
|
|
|
MappedAddress - Supplies whether the address was mapped. This only has
|
|
meaning if the address returned is non-null.
|
|
|
|
Return Value:
|
|
|
|
The mapped address.
|
|
|
|
--*/
|
|
|
|
{
|
|
PHYSICAL_ADDRESS cardAddress;
|
|
PVOID address;
|
|
BOOLEAN returnVal;
|
|
|
|
PAGED_CODE();
|
|
|
|
returnVal = HalTranslateBusAddress(BusType, BusNumber, IoAddress, &AddressSpace,
|
|
&cardAddress);
|
|
if (returnVal == FALSE) {
|
|
|
|
*MappedAddress = FALSE;
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Map the device base address into the virtual address space
|
|
// if the address is in memory space.
|
|
//
|
|
|
|
if (!AddressSpace) {
|
|
|
|
address = MmMapIoSpace(cardAddress, NumberOfBytes, FALSE);
|
|
*MappedAddress = (address ? TRUE : FALSE);
|
|
|
|
} else {
|
|
|
|
address = (PVOID) cardAddress.LowPart;
|
|
*MappedAddress = FALSE;
|
|
}
|
|
|
|
return address;
|
|
}
|
|
|
|
VOID
|
|
PipDecompressEisaId(
|
|
IN ULONG CompressedId,
|
|
OUT PWCHAR EisaId
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine decompressed compressed Eisa Id and returns the Id to caller
|
|
specified character buffer.
|
|
|
|
Arguments:
|
|
|
|
CompressedId - supplies the compressed Eisa Id.
|
|
|
|
EisaId - supplies a 8-wchar buffer to receive the decompressed Eisa Id.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
USHORT c1, c2;
|
|
LONG i;
|
|
|
|
PAGED_CODE();
|
|
|
|
CompressedId &= 0xffffff7f; // remove the reserved bit (bit 7 of byte 0)
|
|
c1 = c2 = (USHORT)CompressedId;
|
|
c1 = (c1 & 0xff) << 8;
|
|
c2 = (c2 & 0xff00) >> 8;
|
|
c1 |= c2;
|
|
for (i = 2; i >= 0; i--) {
|
|
*(EisaId + i) = (WCHAR)(c1 & 0x1f) + 0x40;
|
|
c1 >>= 5;
|
|
}
|
|
EisaId += 3;
|
|
c1 = c2 = (USHORT)(CompressedId >> 16);
|
|
c1 = (c1 & 0xff) << 8;
|
|
c2 = (c2 & 0xff00) >> 8;
|
|
c1 |= c2;
|
|
StringCchPrintf(EisaId,
|
|
5,
|
|
L"%04x",
|
|
c1
|
|
);
|
|
}
|
|
|
|
VOID
|
|
PipLogError(
|
|
IN NTSTATUS ErrorCode,
|
|
IN ULONG UniqueErrorValue,
|
|
IN NTSTATUS FinalStatus,
|
|
IN PULONG DumpData,
|
|
IN ULONG DumpCount,
|
|
IN USHORT StringLength,
|
|
IN PWCHAR String
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine contains common code to write an error log entry. It is
|
|
called from other routines to avoid duplication of code. This routine
|
|
only allows caller to supply one insertion string to the error log.
|
|
|
|
Arguments:
|
|
|
|
ErrorCode - The error code for the error log packet.
|
|
|
|
UniqueErrorValue - The unique error value for the error log packet.
|
|
|
|
FinalStatus - The final status of the operation for the error log packet.
|
|
|
|
DumpData - Pointer to an array of dump data for the error log packet.
|
|
|
|
DumpCount - The number of entries in the dump data array.
|
|
|
|
StringLength - The length of insertion string *NOT* including the NULL terminater.
|
|
|
|
String - The pointer to the insertion string
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIO_ERROR_LOG_PACKET errorLogEntry;
|
|
ULONG i, size;
|
|
PUCHAR p;
|
|
|
|
size = sizeof(IO_ERROR_LOG_PACKET) + DumpCount * sizeof(ULONG) +
|
|
StringLength + sizeof(UNICODE_NULL) - sizeof(ULONG);
|
|
|
|
ASSERT(size <= MAXUCHAR);
|
|
if (size > MAXUCHAR) {
|
|
return;
|
|
}
|
|
|
|
errorLogEntry = (PIO_ERROR_LOG_PACKET) IoAllocateErrorLogEntry(
|
|
PipDriverObject,
|
|
(UCHAR) size
|
|
);
|
|
if (errorLogEntry != NULL) {
|
|
|
|
RtlZeroMemory(errorLogEntry, size);
|
|
|
|
errorLogEntry->ErrorCode = ErrorCode;
|
|
errorLogEntry->DumpDataSize = (USHORT) (DumpCount * sizeof(ULONG));
|
|
errorLogEntry->UniqueErrorValue = UniqueErrorValue;
|
|
errorLogEntry->FinalStatus = FinalStatus;
|
|
for (i = 0; i < DumpCount; i++)
|
|
errorLogEntry->DumpData[i] = DumpData[i];
|
|
if (String) {
|
|
errorLogEntry->NumberOfStrings = 1;
|
|
errorLogEntry->StringOffset = (USHORT)(sizeof(IO_ERROR_LOG_PACKET) +
|
|
DumpCount * sizeof(ULONG) - sizeof(ULONG));
|
|
p= (PUCHAR)errorLogEntry + errorLogEntry->StringOffset;
|
|
|
|
StringCbCopy((PWCHAR)p,
|
|
StringLength + sizeof(UNICODE_NULL),
|
|
String
|
|
);
|
|
}
|
|
IoWriteErrorLogEntry(errorLogEntry);
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
PipOpenCurrentHwProfileDeviceInstanceKey(
|
|
OUT PHANDLE Handle,
|
|
IN PUNICODE_STRING DeviceInstanceName,
|
|
IN ACCESS_MASK DesiredAccess
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sets the csconfig flags for the specified device
|
|
which is specified by the instance number under ServiceKeyName\Enum.
|
|
|
|
Arguments:
|
|
|
|
ServiceKeyName - Supplies a pointer to the name of the subkey in the
|
|
system service list (HKEY_LOCAL_MACHINE\CurrentControlSet\Services)
|
|
that caused the driver to load. This is the RegistryPath parameter
|
|
to the DriverEntry routine.
|
|
|
|
Instance - Supplies the instance value under ServiceKeyName\Enum key
|
|
|
|
DesiredAccess - Specifies the desired access that the caller needs to
|
|
the key.
|
|
|
|
Create - Determines if the key is to be created if it does not exist.
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
UNICODE_STRING unicodeString;
|
|
HANDLE profileEnumHandle;
|
|
|
|
//
|
|
// See if we can open the device instance key of current hardware profile
|
|
//
|
|
RtlInitUnicodeString (
|
|
&unicodeString,
|
|
L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET\\HARDWARE PROFILES\\CURRENT\\SYSTEM\\CURRENTCONTROLSET\\ENUM"
|
|
);
|
|
status = PipOpenRegistryKey(&profileEnumHandle,
|
|
NULL,
|
|
&unicodeString,
|
|
KEY_READ,
|
|
FALSE
|
|
);
|
|
if (NT_SUCCESS(status)) {
|
|
status = PipOpenRegistryKey(Handle,
|
|
profileEnumHandle,
|
|
DeviceInstanceName,
|
|
DesiredAccess,
|
|
FALSE
|
|
);
|
|
ZwClose(profileEnumHandle);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipGetDeviceInstanceCsConfigFlags(
|
|
IN PUNICODE_STRING DeviceInstance,
|
|
OUT PULONG CsConfigFlags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine retrieves the csconfig flags for the specified device
|
|
which is specified by the instance number under ServiceKeyName\Enum.
|
|
|
|
Arguments:
|
|
|
|
ServiceKeyName - Supplies a pointer to the name of the subkey in the
|
|
system service list (HKEY_LOCAL_MACHINE\CurrentControlSet\Services)
|
|
that caused the driver to load.
|
|
|
|
// Instance - Supplies the instance value under ServiceKeyName\Enum key
|
|
//
|
|
CsConfigFlags - Supplies a variable to receive the device's CsConfigFlags
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
HANDLE handle;
|
|
PKEY_VALUE_FULL_INFORMATION keyValueInformation;
|
|
|
|
*CsConfigFlags = 0;
|
|
|
|
status = PipOpenCurrentHwProfileDeviceInstanceKey(&handle,
|
|
DeviceInstance,
|
|
KEY_READ
|
|
);
|
|
if(NT_SUCCESS(status)) {
|
|
status = PipGetRegistryValue(handle,
|
|
L"CsConfigFlags",
|
|
&keyValueInformation
|
|
);
|
|
if(NT_SUCCESS(status)) {
|
|
if((keyValueInformation->Type == REG_DWORD) &&
|
|
(keyValueInformation->DataLength >= sizeof(ULONG))) {
|
|
*CsConfigFlags = *(PULONG)KEY_VALUE_DATA(keyValueInformation);
|
|
}
|
|
ExFreePool(keyValueInformation);
|
|
}
|
|
ZwClose(handle);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
ULONG
|
|
PipDetermineResourceListSize(
|
|
IN PCM_RESOURCE_LIST ResourceList
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine determines size of the passed in ResourceList
|
|
structure.
|
|
|
|
Arguments:
|
|
|
|
Configuration1 - Supplies a pointer to the resource list.
|
|
|
|
Return Value:
|
|
|
|
size of the resource list structure.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG totalSize, listSize, descriptorSize, i, j;
|
|
PCM_FULL_RESOURCE_DESCRIPTOR fullResourceDesc;
|
|
PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptor;
|
|
|
|
if (!ResourceList) {
|
|
totalSize = 0;
|
|
} else {
|
|
totalSize = FIELD_OFFSET(CM_RESOURCE_LIST, List);
|
|
fullResourceDesc = &ResourceList->List[0];
|
|
for (i = 0; i < ResourceList->Count; i++) {
|
|
listSize = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR,
|
|
PartialResourceList) +
|
|
FIELD_OFFSET(CM_PARTIAL_RESOURCE_LIST,
|
|
PartialDescriptors);
|
|
partialDescriptor = &fullResourceDesc->PartialResourceList.PartialDescriptors[0];
|
|
for (j = 0; j < fullResourceDesc->PartialResourceList.Count; j++) {
|
|
descriptorSize = sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
|
|
if (partialDescriptor->Type == CmResourceTypeDeviceSpecific) {
|
|
descriptorSize += partialDescriptor->u.DeviceSpecificData.DataSize;
|
|
}
|
|
listSize += descriptorSize;
|
|
partialDescriptor = (PCM_PARTIAL_RESOURCE_DESCRIPTOR)
|
|
((PUCHAR)partialDescriptor + descriptorSize);
|
|
}
|
|
totalSize += listSize;
|
|
fullResourceDesc = (PCM_FULL_RESOURCE_DESCRIPTOR)
|
|
((PUCHAR)fullResourceDesc + listSize);
|
|
}
|
|
}
|
|
return totalSize;
|
|
}
|
|
NTSTATUS
|
|
PipMapAddressAndCmdPort (
|
|
IN PPI_BUS_EXTENSION BusExtension
|
|
)
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
ULONG dumpData[3];
|
|
PHYSICAL_ADDRESS physicalAddress;
|
|
//
|
|
// Map port addr to memory addr if necessary.
|
|
//
|
|
|
|
if (PipAddressPort == NULL) {
|
|
physicalAddress.LowPart = ADDRESS_PORT;
|
|
physicalAddress.HighPart = 0;
|
|
BusExtension->AddressPort =
|
|
PipAddressPort = PipGetMappedAddress(
|
|
Isa, // InterfaceType
|
|
0, // BusNumber,
|
|
physicalAddress,
|
|
1,
|
|
CM_RESOURCE_PORT_IO,
|
|
&BusExtension->AddrPortMapped
|
|
);
|
|
if (PipAddressPort == NULL) {
|
|
dumpData[0] = ADDRESS_PORT;
|
|
dumpData[1] = 1;
|
|
dumpData[2] = CM_RESOURCE_PORT_IO;
|
|
PipLogError(PNPISA_REGISTER_NOT_MAPPED,
|
|
PNPISA_ACQUIREPORTRESOURCE_1,
|
|
STATUS_INSUFFICIENT_RESOURCES,
|
|
dumpData,
|
|
3,
|
|
0,
|
|
NULL
|
|
);
|
|
status = STATUS_UNSUCCESSFUL;
|
|
}
|
|
}
|
|
if (PipCommandPort == NULL) {
|
|
physicalAddress.LowPart = COMMAND_PORT;
|
|
physicalAddress.HighPart = 0;
|
|
BusExtension->CommandPort =
|
|
PipCommandPort = PipGetMappedAddress(
|
|
Isa, // InterfaceType
|
|
0, // BusNumber,
|
|
physicalAddress,
|
|
1,
|
|
CM_RESOURCE_PORT_IO,
|
|
&BusExtension->CmdPortMapped
|
|
);
|
|
if (PipCommandPort == NULL) {
|
|
dumpData[0] = COMMAND_PORT;
|
|
dumpData[1] = 1;
|
|
dumpData[2] = CM_RESOURCE_PORT_IO;
|
|
PipLogError(PNPISA_REGISTER_NOT_MAPPED,
|
|
PNPISA_ACQUIREPORTRESOURCE_2,
|
|
STATUS_INSUFFICIENT_RESOURCES,
|
|
dumpData,
|
|
3,
|
|
0,
|
|
NULL
|
|
);
|
|
status = STATUS_UNSUCCESSFUL;
|
|
}
|
|
}
|
|
|
|
|
|
return status;
|
|
|
|
|
|
|
|
}
|
|
|
|
VOID
|
|
PipReleaseDeviceResources (
|
|
PDEVICE_INFORMATION DeviceInfo
|
|
)
|
|
{
|
|
UNICODE_STRING unicodeString;
|
|
|
|
// This code is here rather than in the following conditional as
|
|
// this best reflects how the code used to work before this code
|
|
// was moved here from PDO stop/remove/surprise remove.
|
|
if (DeviceInfo->LogConfHandle) {
|
|
RtlInitUnicodeString(&unicodeString, L"AllocConfig");
|
|
ZwDeleteValueKey (DeviceInfo->LogConfHandle, &unicodeString);
|
|
}
|
|
|
|
if (DeviceInfo->AllocatedResources) {
|
|
ExFreePool (DeviceInfo->AllocatedResources);
|
|
DeviceInfo->AllocatedResources=NULL;
|
|
|
|
if (DeviceInfo->LogConfHandle) {
|
|
// As it stands now it we will close the logconf handle if
|
|
// the device gets removed, surprise removed, or stopped.
|
|
// When we get started, we'll try to re-create the
|
|
// AllocConfig value but fail because of the lack of the
|
|
// logconf handle. This is not a change in behavior.
|
|
//
|
|
// The ZwDeleteKey() was definitely bogus though.
|
|
|
|
ZwClose(DeviceInfo->LogConfHandle);
|
|
DeviceInfo->LogConfHandle=NULL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
PipReportStateChange(
|
|
PNPISA_STATE State
|
|
)
|
|
{
|
|
DebugPrint((DEBUG_STATE, "State transition: %d to %d\n",
|
|
PipState, State));
|
|
PipState = State;
|
|
}
|
|
|
|
ULONG
|
|
PipGetCardFlags(
|
|
PCARD_INFORMATION CardInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Look in the registry for any flags for this CardId
|
|
|
|
Arguments:
|
|
|
|
CardId First 4 bytes of ISAPNP config space
|
|
|
|
Return Value:
|
|
|
|
32 bit flags value from registry or 0 if not found.
|
|
|
|
--*/
|
|
|
|
{
|
|
HANDLE serviceHandle, paramHandle;
|
|
NTSTATUS status;
|
|
ULONG flags, returnedLength;
|
|
UNICODE_STRING nameString;
|
|
WCHAR nameBuffer[9];
|
|
WCHAR eisaId[8];
|
|
const PWCHAR paramKey = L"Parameters";
|
|
struct {
|
|
KEY_VALUE_PARTIAL_INFORMATION Header;
|
|
|
|
//
|
|
// The header contains enough space for one UCHAR, pad
|
|
// it out by a ULONG, this will ensure the structure
|
|
// is large enough for at lease the ULONG we need.
|
|
//
|
|
// N.B. Natural alignment will get it out far enough that
|
|
// this ULONG is 4 bytes to many.
|
|
//
|
|
|
|
ULONG Pad;
|
|
} returnedData;
|
|
|
|
|
|
status = PipOpenRegistryKey(&serviceHandle,
|
|
NULL,
|
|
&PipRegistryPath,
|
|
KEY_READ,
|
|
FALSE);
|
|
if (!NT_SUCCESS(status)) {
|
|
return 0;
|
|
}
|
|
|
|
RtlInitUnicodeString(&nameString, paramKey);
|
|
status = PipOpenRegistryKey(¶mHandle,
|
|
serviceHandle,
|
|
&nameString,
|
|
KEY_READ,
|
|
FALSE);
|
|
if (!NT_SUCCESS(status)) {
|
|
ZwClose(serviceHandle);
|
|
return 0;
|
|
}
|
|
|
|
PipDecompressEisaId(
|
|
((PSERIAL_IDENTIFIER) (CardInfo->CardData))->VenderId,
|
|
eisaId
|
|
);
|
|
RtlInitUnicodeString(&nameString, eisaId);
|
|
|
|
//
|
|
// Get the "value" of this value.
|
|
//
|
|
|
|
status = ZwQueryValueKey(
|
|
paramHandle,
|
|
&nameString,
|
|
KeyValuePartialInformation,
|
|
&returnedData,
|
|
sizeof(returnedData),
|
|
&returnedLength
|
|
);
|
|
ZwClose(paramHandle);
|
|
ZwClose(serviceHandle);
|
|
|
|
if (NT_SUCCESS(status) && (returnedData.Header.Type == REG_DWORD) &&
|
|
(returnedData.Header.DataLength == sizeof(ULONG))) {
|
|
flags = *(PULONG)(returnedData.Header.Data);
|
|
DebugPrint((DEBUG_WARN, "Retrieving card flags for %ws: %x\n",
|
|
nameString.Buffer, flags));
|
|
} else {
|
|
flags = 0;
|
|
}
|
|
return flags;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipBuildValueName(
|
|
IN PDEVICE_INFORMATION DeviceInfo,
|
|
IN PWSTR Suffix,
|
|
OUT PWSTR *ValuePath
|
|
)
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Builds a name describing the device via the device id and unique
|
|
id. Used to store per-device info in our parent's BiosConfig key
|
|
|
|
Arguments:
|
|
|
|
DeviceInfo Pointer to the PDO Extension for this device.
|
|
|
|
Suffix Suffix for value name
|
|
|
|
IrqFlags The edge or level setting of the boot config
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PWSTR DeviceId = NULL, Instance = NULL;
|
|
PWSTR Buffer, Current;
|
|
ULONG length, deviceIdLength, instanceIdLength;
|
|
|
|
status = PipQueryDeviceId(DeviceInfo, &DeviceId, &deviceIdLength, 0);
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
status = PipQueryDeviceUniqueId(DeviceInfo, &Instance, &instanceIdLength);
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
length = deviceIdLength + instanceIdLength + (wcslen(Suffix) + 1) * sizeof(WCHAR);
|
|
|
|
Buffer = ExAllocatePool(PagedPool, length);
|
|
if (Buffer == NULL) {
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto cleanup;
|
|
}
|
|
|
|
StringCbCopy(Buffer,
|
|
length,
|
|
DeviceId
|
|
);
|
|
|
|
StringCbCat(Buffer,
|
|
length,
|
|
Instance
|
|
);
|
|
|
|
StringCbCat(Buffer,
|
|
length,
|
|
Suffix
|
|
);
|
|
|
|
Current = Buffer;
|
|
while (*Current != UNICODE_NULL) {
|
|
if (*Current == L'\\') {
|
|
*Current = L'_';
|
|
}
|
|
Current++;
|
|
}
|
|
|
|
cleanup:
|
|
if (Instance) {
|
|
ExFreePool(Instance);
|
|
}
|
|
|
|
if (DeviceId) {
|
|
ExFreePool(DeviceId);
|
|
}
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
*ValuePath = Buffer;
|
|
} else {
|
|
*ValuePath = NULL;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipSaveBootResources(
|
|
IN PDEVICE_INFORMATION DeviceInfo
|
|
)
|
|
/*++
|
|
|
|
Description:
|
|
|
|
This saves the per-boot configuration of a device in the registry
|
|
|
|
Arguments:
|
|
|
|
DeviceInfo Pointer to the PDO Extension for this device.
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
OBJECT_ATTRIBUTES attributes;
|
|
UNICODE_STRING unicodeString;
|
|
HANDLE deviceHandle, configHandle;
|
|
PWSTR Buffer = NULL;
|
|
ULONG Flags;
|
|
|
|
PAGED_CODE();
|
|
|
|
status = IoOpenDeviceRegistryKey(DeviceInfo->ParentDeviceExtension->PhysicalBusDevice,
|
|
PLUGPLAY_REGKEY_DEVICE,
|
|
KEY_WRITE,
|
|
&deviceHandle
|
|
);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
RtlInitUnicodeString(&unicodeString, BIOS_CONFIG_KEY_NAME);
|
|
|
|
InitializeObjectAttributes(&attributes,
|
|
&unicodeString,
|
|
OBJ_KERNEL_HANDLE,
|
|
deviceHandle,
|
|
NULL
|
|
);
|
|
|
|
status = ZwCreateKey(&configHandle,
|
|
KEY_WRITE,
|
|
&attributes,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_VOLATILE,
|
|
NULL
|
|
);
|
|
|
|
ZwClose(deviceHandle);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
status = PipBuildValueName(DeviceInfo, BOOTRESOURCES_VALUE_NAME,
|
|
&Buffer);
|
|
if (!NT_SUCCESS(status)) {
|
|
Buffer = NULL;
|
|
goto cleanup;
|
|
}
|
|
|
|
RtlInitUnicodeString(&unicodeString, Buffer);
|
|
|
|
status = ZwSetValueKey(configHandle,
|
|
&unicodeString,
|
|
0,
|
|
REG_BINARY,
|
|
DeviceInfo->BootResources,
|
|
DeviceInfo->BootResourcesLength
|
|
);
|
|
|
|
ZwClose(configHandle);
|
|
|
|
cleanup:
|
|
if (Buffer != NULL) {
|
|
ExFreePool(Buffer);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipSaveBootIrqFlags(
|
|
IN PDEVICE_INFORMATION DeviceInfo,
|
|
IN USHORT IrqFlags
|
|
)
|
|
/*++
|
|
|
|
Description:
|
|
|
|
This saves the per-boot irq configuration of a device in the registry
|
|
|
|
Arguments:
|
|
|
|
DeviceInfo Pointer to the PDO Extension for this device.
|
|
|
|
IrqFlags The edge or level setting of the boot config
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
OBJECT_ATTRIBUTES attributes;
|
|
UNICODE_STRING unicodeString;
|
|
HANDLE deviceHandle, configHandle;
|
|
PWSTR Buffer = NULL;
|
|
ULONG Flags;
|
|
|
|
PAGED_CODE();
|
|
|
|
Flags = (ULONG) IrqFlags;
|
|
|
|
status = IoOpenDeviceRegistryKey(DeviceInfo->ParentDeviceExtension->PhysicalBusDevice,
|
|
PLUGPLAY_REGKEY_DEVICE,
|
|
KEY_WRITE,
|
|
&deviceHandle
|
|
);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
RtlInitUnicodeString(&unicodeString, BIOS_CONFIG_KEY_NAME);
|
|
|
|
InitializeObjectAttributes(&attributes,
|
|
&unicodeString,
|
|
OBJ_KERNEL_HANDLE,
|
|
deviceHandle,
|
|
NULL
|
|
);
|
|
|
|
status = ZwCreateKey(&configHandle,
|
|
KEY_WRITE,
|
|
&attributes,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_VOLATILE,
|
|
NULL
|
|
);
|
|
|
|
ZwClose(deviceHandle);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
status = PipBuildValueName(DeviceInfo, IRQFLAGS_VALUE_NAME, &Buffer);
|
|
if (!NT_SUCCESS(status)) {
|
|
Buffer = NULL;
|
|
goto cleanup;
|
|
}
|
|
|
|
RtlInitUnicodeString(&unicodeString, Buffer);
|
|
|
|
status = ZwSetValueKey(configHandle,
|
|
&unicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Flags,
|
|
sizeof(ULONG)
|
|
);
|
|
|
|
ZwClose(configHandle);
|
|
|
|
cleanup:
|
|
if (Buffer != NULL) {
|
|
ExFreePool(Buffer);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipGetSavedBootResources(
|
|
IN PDEVICE_INFORMATION DeviceInfo,
|
|
OUT PCM_RESOURCE_LIST *BootResources
|
|
)
|
|
/*
|
|
|
|
Description:
|
|
|
|
This retrieves the saved boot resources
|
|
|
|
Arguments:
|
|
|
|
DeviceInfo Pointer to the PDO Extension for this device.
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
UNICODE_STRING unicodeString;
|
|
NTSTATUS status;
|
|
OBJECT_ATTRIBUTES attributes;
|
|
HANDLE deviceHandle, configHandle;
|
|
PWSTR Buffer = NULL;
|
|
PKEY_VALUE_PARTIAL_INFORMATION info = NULL;
|
|
ULONG resultLength;
|
|
|
|
PAGED_CODE();
|
|
|
|
*BootResources = NULL;
|
|
status = IoOpenDeviceRegistryKey(DeviceInfo->ParentDeviceExtension->PhysicalBusDevice,
|
|
PLUGPLAY_REGKEY_DEVICE,
|
|
KEY_READ | KEY_WRITE,
|
|
&deviceHandle
|
|
);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
RtlInitUnicodeString(&unicodeString, BIOS_CONFIG_KEY_NAME);
|
|
|
|
InitializeObjectAttributes(&attributes,
|
|
&unicodeString,
|
|
OBJ_KERNEL_HANDLE,
|
|
deviceHandle,
|
|
NULL
|
|
);
|
|
|
|
status = ZwOpenKey(&configHandle,
|
|
KEY_READ,
|
|
&attributes
|
|
);
|
|
|
|
ZwClose(deviceHandle);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
status = PipBuildValueName(DeviceInfo, BOOTRESOURCES_VALUE_NAME, &Buffer);
|
|
if (!NT_SUCCESS(status)) {
|
|
ZwClose(configHandle);
|
|
Buffer = NULL;
|
|
goto cleanup;
|
|
}
|
|
|
|
RtlInitUnicodeString(&unicodeString,Buffer);
|
|
|
|
status = ZwQueryValueKey(configHandle,
|
|
&unicodeString,
|
|
KeyValuePartialInformation,
|
|
NULL,
|
|
0,
|
|
&resultLength
|
|
);
|
|
if (status != STATUS_BUFFER_OVERFLOW &&
|
|
status != STATUS_BUFFER_TOO_SMALL) {
|
|
ZwClose(configHandle);
|
|
goto cleanup;
|
|
}
|
|
|
|
info = ExAllocatePool(PagedPool, resultLength);
|
|
if (info == NULL) {
|
|
ZwClose(configHandle);
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto cleanup;
|
|
}
|
|
|
|
status = ZwQueryValueKey(configHandle,
|
|
&unicodeString,
|
|
KeyValuePartialInformation,
|
|
info,
|
|
resultLength,
|
|
&resultLength
|
|
);
|
|
ZwClose(configHandle);
|
|
if (!NT_SUCCESS(status)) {
|
|
DebugPrint((DEBUG_PNP, "Failed to get boot resources from registry for %ws\n", Buffer));
|
|
goto cleanup;
|
|
}
|
|
|
|
status = PipValidateResourceList((PCM_RESOURCE_LIST)info->Data, info->DataLength);
|
|
if (!NT_SUCCESS(status)) {
|
|
*BootResources = NULL;
|
|
goto cleanup;
|
|
}
|
|
|
|
*BootResources = ExAllocatePool(PagedPool, info->DataLength);
|
|
if (*BootResources) {
|
|
RtlCopyMemory(*BootResources, info->Data, info->DataLength);
|
|
DebugPrint((DEBUG_PNP, "Got boot resources from registry for %ws\n", Buffer));
|
|
} else {
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if (info != NULL) {
|
|
ExFreePool(info);
|
|
}
|
|
|
|
if (Buffer != NULL) {
|
|
ExFreePool(Buffer);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipGetBootIrqFlags(
|
|
IN PDEVICE_INFORMATION DeviceInfo,
|
|
OUT PUSHORT IrqFlags
|
|
)
|
|
/*
|
|
|
|
Description:
|
|
|
|
This retrieves the per-boot irq configuration of a device from the registry
|
|
|
|
Arguments:
|
|
|
|
DeviceInfo Pointer to the PDO Extension for this device.
|
|
|
|
IrqFlags - flags we originally derived from the device's boot
|
|
config on this boot
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
OBJECT_ATTRIBUTES attributes;
|
|
UNICODE_STRING unicodeString;
|
|
HANDLE deviceHandle, configHandle;
|
|
PWSTR Buffer = NULL;
|
|
CHAR returnBuffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG) - 1];
|
|
PKEY_VALUE_PARTIAL_INFORMATION info;
|
|
ULONG resultLength;
|
|
|
|
PAGED_CODE();
|
|
|
|
status = IoOpenDeviceRegistryKey(DeviceInfo->ParentDeviceExtension->PhysicalBusDevice,
|
|
PLUGPLAY_REGKEY_DEVICE,
|
|
KEY_READ,
|
|
&deviceHandle
|
|
);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
RtlInitUnicodeString(&unicodeString, BIOS_CONFIG_KEY_NAME);
|
|
|
|
InitializeObjectAttributes(&attributes,
|
|
&unicodeString,
|
|
OBJ_KERNEL_HANDLE,
|
|
deviceHandle,
|
|
NULL
|
|
);
|
|
|
|
status = ZwOpenKey(&configHandle,
|
|
KEY_READ,
|
|
&attributes
|
|
);
|
|
|
|
ZwClose(deviceHandle);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
status = PipBuildValueName(DeviceInfo, IRQFLAGS_VALUE_NAME, &Buffer);
|
|
if (!NT_SUCCESS(status)) {
|
|
ZwClose(configHandle);
|
|
Buffer = NULL;
|
|
goto cleanup;
|
|
}
|
|
|
|
RtlInitUnicodeString(&unicodeString,Buffer);
|
|
|
|
status = ZwQueryValueKey(configHandle,
|
|
&unicodeString,
|
|
KeyValuePartialInformation,
|
|
returnBuffer,
|
|
sizeof(returnBuffer),
|
|
&resultLength
|
|
);
|
|
|
|
ZwClose(configHandle);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
ULONG Temp;
|
|
|
|
info = (PKEY_VALUE_PARTIAL_INFORMATION) returnBuffer;
|
|
|
|
ASSERT(info->DataLength == sizeof(ULONG));
|
|
|
|
Temp = *((PULONG) info->Data);
|
|
ASSERT(!(Temp & 0xFFFF0000));
|
|
*IrqFlags = (USHORT) Temp;
|
|
|
|
DebugPrint((DEBUG_IRQ, "Got Irq Flags of %d for %ws\n",
|
|
(ULONG) *IrqFlags,
|
|
unicodeString.Buffer));
|
|
} else {
|
|
DebugPrint((DEBUG_IRQ, "Failed to get irq flags for %ws\n",
|
|
unicodeString.Buffer));
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if (Buffer != NULL) {
|
|
ExFreePool(Buffer);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
VOID
|
|
PipResetGlobals (
|
|
VOID
|
|
)
|
|
{
|
|
PipReadDataPort = PipCommandPort = PipAddressPort = NULL;
|
|
PipRDPNode = NULL;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
NTSTATUS
|
|
PipOpenRegistryKey(
|
|
OUT PHANDLE Handle,
|
|
IN HANDLE BaseHandle OPTIONAL,
|
|
IN PUNICODE_STRING KeyName,
|
|
IN ACCESS_MASK DesiredAccess,
|
|
IN BOOLEAN Create
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens or creates a VOLATILE registry key using the name passed in based
|
|
at the BaseHandle node.
|
|
|
|
Arguments:
|
|
|
|
Handle - Pointer to the handle which will contain the registry key that
|
|
was opened.
|
|
|
|
BaseHandle - Handle to the base path from which the key must be opened.
|
|
|
|
KeyName - Name of the Key that must be opened/created.
|
|
|
|
DesiredAccess - Specifies the desired access that the caller needs to
|
|
the key.
|
|
|
|
Create - Determines if the key is to be created if it does not exist.
|
|
|
|
Return Value:
|
|
|
|
The function value is the final status of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
OBJECT_ATTRIBUTES objectAttributes;
|
|
ULONG disposition;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Initialize the object for the key.
|
|
//
|
|
|
|
InitializeObjectAttributes( &objectAttributes,
|
|
KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
BaseHandle,
|
|
(PSECURITY_DESCRIPTOR) NULL );
|
|
|
|
//
|
|
// Create the key or open it, as appropriate based on the caller's
|
|
// wishes.
|
|
//
|
|
|
|
if (Create) {
|
|
return ZwCreateKey( Handle,
|
|
DesiredAccess,
|
|
&objectAttributes,
|
|
0,
|
|
(PUNICODE_STRING) NULL,
|
|
REG_OPTION_VOLATILE,
|
|
&disposition );
|
|
} else {
|
|
return ZwOpenKey( Handle,
|
|
DesiredAccess,
|
|
&objectAttributes );
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
PipGetRegistryValue(
|
|
IN HANDLE KeyHandle,
|
|
IN PWSTR ValueName,
|
|
OUT PKEY_VALUE_FULL_INFORMATION *Information
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is invoked to retrieve the data for a registry key's value.
|
|
This is done by querying the value of the key with a zero-length buffer
|
|
to determine the size of the value, and then allocating a buffer and
|
|
actually querying the value into the buffer.
|
|
|
|
It is the responsibility of the caller to free the buffer.
|
|
|
|
Arguments:
|
|
|
|
KeyHandle - Supplies the key handle whose value is to be queried
|
|
|
|
ValueName - Supplies the null-terminated Unicode name of the value.
|
|
|
|
Information - Returns a pointer to the allocated data buffer.
|
|
|
|
Return Value:
|
|
|
|
The function value is the final status of the query operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
UNICODE_STRING unicodeString;
|
|
NTSTATUS status;
|
|
PKEY_VALUE_FULL_INFORMATION infoBuffer;
|
|
ULONG keyValueLength;
|
|
|
|
PAGED_CODE();
|
|
|
|
*Information = NULL;
|
|
RtlInitUnicodeString( &unicodeString, ValueName );
|
|
|
|
//
|
|
// Figure out how big the data value is so that a buffer of the
|
|
// appropriate size can be allocated.
|
|
//
|
|
|
|
status = ZwQueryValueKey( KeyHandle,
|
|
&unicodeString,
|
|
KeyValueFullInformation,
|
|
(PVOID) NULL,
|
|
0,
|
|
&keyValueLength );
|
|
if (status != STATUS_BUFFER_OVERFLOW &&
|
|
status != STATUS_BUFFER_TOO_SMALL) {
|
|
return status;
|
|
}
|
|
|
|
//
|
|
// Allocate a buffer large enough to contain the entire key data value.
|
|
//
|
|
|
|
infoBuffer = ExAllocatePool( NonPagedPool, keyValueLength );
|
|
if (!infoBuffer) {
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Query the data for the key value.
|
|
//
|
|
|
|
status = ZwQueryValueKey( KeyHandle,
|
|
&unicodeString,
|
|
KeyValueFullInformation,
|
|
infoBuffer,
|
|
keyValueLength,
|
|
&keyValueLength );
|
|
if (!NT_SUCCESS( status )) {
|
|
ExFreePool( infoBuffer );
|
|
return status;
|
|
}
|
|
|
|
//
|
|
// Everything worked, so simply return the address of the allocated
|
|
// buffer to the caller, who is now responsible for freeing it.
|
|
//
|
|
|
|
*Information = infoBuffer;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
BOOLEAN
|
|
PiNeedDeferISABridge(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
)
|
|
{
|
|
BOOLEAN defer=FALSE;
|
|
NTSTATUS status;
|
|
HANDLE hKey;
|
|
ULONG value;
|
|
PKEY_VALUE_FULL_INFORMATION keyValueInformation;
|
|
|
|
|
|
|
|
status = IoOpenDeviceRegistryKey (DeviceObject,PLUGPLAY_REGKEY_DEVICE,KEY_READ,&hKey);
|
|
|
|
if (NT_SUCCESS (status)) {
|
|
status = PipGetRegistryValue (hKey,&BRIDGE_CHECK_KEY,&keyValueInformation);
|
|
|
|
if (NT_SUCCESS (status)) {
|
|
if((keyValueInformation->Type == REG_DWORD) &&
|
|
(keyValueInformation->DataLength >= sizeof(ULONG))) {
|
|
value = *(PULONG)KEY_VALUE_DATA(keyValueInformation);
|
|
//
|
|
// Assume that if the value !0 then the bridge is 'broken'
|
|
//
|
|
defer = (value == 0)?FALSE:TRUE;
|
|
}
|
|
}
|
|
ZwClose(hKey);
|
|
|
|
}
|
|
|
|
return defer;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipValidateResourceList(
|
|
IN PCM_RESOURCE_LIST ResourceList,
|
|
IN ULONG Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine verifies that a resource list structure is properly
|
|
formated and the buffer containing it is large enough.
|
|
|
|
Arguments:
|
|
|
|
ResourceList - The CM_RESOURCE_LIST to verify.
|
|
|
|
Length - The length of the ResourceList buffer.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS if the resource list is valid
|
|
STATUS_UNSUCCESSFUL otherwise.
|
|
|
|
--*/
|
|
{
|
|
ULONG requiredLength;
|
|
|
|
if (Length < sizeof(CM_RESOURCE_LIST)) {
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
if (ResourceList->Count != 1) {
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
requiredLength = sizeof(CM_RESOURCE_LIST);
|
|
|
|
if (ResourceList->List[0].PartialResourceList.Count > 1) {
|
|
|
|
requiredLength += sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * (ResourceList->List[0].PartialResourceList.Count - 1);
|
|
}
|
|
|
|
if (requiredLength > Length) {
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
#if DBG
|
|
|
|
VOID
|
|
PipDebugPrintContinue (
|
|
ULONG Level,
|
|
PCCHAR DebugMessage,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine displays debugging message or causes a break.
|
|
|
|
Arguments:
|
|
|
|
Level - supplies debugging levelcode. DEBUG_MESSAGE - displays message only.
|
|
DEBUG_BREAK - displays message and break.
|
|
|
|
DebugMessage - supplies a pointer to the debugging message.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, DebugMessage);
|
|
|
|
vDbgPrintEx(DPFLTR_ISAPNP_ID,
|
|
Level,
|
|
DebugMessage,
|
|
ap
|
|
);
|
|
|
|
if (Level & DEBUG_BREAK) {
|
|
DbgBreakPoint();
|
|
}
|
|
|
|
va_end(ap);
|
|
}
|
|
|
|
|
|
VOID
|
|
PipDebugPrint (
|
|
ULONG Level,
|
|
PCCHAR DebugMessage,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine displays debugging message or causes a break.
|
|
|
|
Arguments:
|
|
|
|
Level - supplies debugging levelcode. DEBUG_MESSAGE - displays message only.
|
|
DEBUG_BREAK - displays message and break.
|
|
|
|
DebugMessage - supplies a pointer to the debugging message.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, DebugMessage);
|
|
|
|
vDbgPrintExWithPrefix("ISAPNP: ",
|
|
DPFLTR_ISAPNP_ID,
|
|
Level,
|
|
DebugMessage,
|
|
ap
|
|
);
|
|
|
|
if (Level & DEBUG_BREAK) {
|
|
DbgBreakPoint();
|
|
}
|
|
|
|
va_end(ap);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
VOID
|
|
PipDumpIoResourceDescriptor (
|
|
IN PUCHAR Indent,
|
|
IN PIO_RESOURCE_DESCRIPTOR Desc
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine processes a IO_RESOURCE_DESCRIPTOR and displays it.
|
|
|
|
Arguments:
|
|
|
|
Indent - # char of indentation.
|
|
|
|
Desc - supplies a pointer to the IO_RESOURCE_DESCRIPTOR to be displayed.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
UCHAR c = ' ';
|
|
|
|
if (Desc->Option == IO_RESOURCE_ALTERNATIVE) {
|
|
c = 'A';
|
|
} else if (Desc->Option == IO_RESOURCE_PREFERRED) {
|
|
c = 'P';
|
|
}
|
|
switch (Desc->Type) {
|
|
case CmResourceTypePort:
|
|
DebugPrint ((
|
|
DEBUG_RESOURCE,
|
|
"%sIO %c Min: %x:%08x, Max: %x:%08x, Algn: %x, Len %x\n",
|
|
Indent, c,
|
|
Desc->u.Port.MinimumAddress.HighPart, Desc->u.Port.MinimumAddress.LowPart,
|
|
Desc->u.Port.MaximumAddress.HighPart, Desc->u.Port.MaximumAddress.LowPart,
|
|
Desc->u.Port.Alignment,
|
|
Desc->u.Port.Length
|
|
));
|
|
break;
|
|
|
|
case CmResourceTypeMemory:
|
|
DebugPrint ((
|
|
DEBUG_RESOURCE,
|
|
"%sMEM %c Min: %x:%08x, Max: %x:%08x, Algn: %x, Len %x\n",
|
|
Indent, c,
|
|
Desc->u.Memory.MinimumAddress.HighPart, Desc->u.Memory.MinimumAddress.LowPart,
|
|
Desc->u.Memory.MaximumAddress.HighPart, Desc->u.Memory.MaximumAddress.LowPart,
|
|
Desc->u.Memory.Alignment,
|
|
Desc->u.Memory.Length
|
|
));
|
|
break;
|
|
|
|
case CmResourceTypeInterrupt:
|
|
DebugPrint ((
|
|
DEBUG_RESOURCE,
|
|
"%sINT %c Min: %x, Max: %x\n",
|
|
Indent, c,
|
|
Desc->u.Interrupt.MinimumVector,
|
|
Desc->u.Interrupt.MaximumVector
|
|
));
|
|
break;
|
|
|
|
case CmResourceTypeDma:
|
|
DebugPrint ((
|
|
DEBUG_RESOURCE,
|
|
"%sDMA %c Min: %x, Max: %x\n",
|
|
Indent, c,
|
|
Desc->u.Dma.MinimumChannel,
|
|
Desc->u.Dma.MaximumChannel
|
|
));
|
|
break;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PipDumpIoResourceList (
|
|
IN PIO_RESOURCE_REQUIREMENTS_LIST IoList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine displays Io resource requirements list.
|
|
|
|
Arguments:
|
|
|
|
IoList - supplies a pointer to the Io resource requirements list to be displayed.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
|
|
|
|
PIO_RESOURCE_LIST resList;
|
|
PIO_RESOURCE_DESCRIPTOR resDesc;
|
|
ULONG listCount, count, i, j;
|
|
|
|
if (IoList == NULL) {
|
|
return;
|
|
}
|
|
DebugPrint((DEBUG_RESOURCE,
|
|
"Pnp Bios IO Resource Requirements List for Slot %x -\n",
|
|
IoList->SlotNumber
|
|
));
|
|
DebugPrint((DEBUG_RESOURCE,
|
|
" List Count = %x, Bus Number = %x\n",
|
|
IoList->AlternativeLists,
|
|
IoList->BusNumber
|
|
));
|
|
listCount = IoList->AlternativeLists;
|
|
resList = &IoList->List[0];
|
|
for (i = 0; i < listCount; i++) {
|
|
DebugPrint((DEBUG_RESOURCE,
|
|
" Version = %x, Revision = %x, Desc count = %x\n",
|
|
resList->Version, resList->Revision, resList->Count
|
|
));
|
|
resDesc = &resList->Descriptors[0];
|
|
count = resList->Count;
|
|
for (j = 0; j < count; j++) {
|
|
PipDumpIoResourceDescriptor(" ", resDesc);
|
|
resDesc++;
|
|
}
|
|
resList = (PIO_RESOURCE_LIST) resDesc;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PipDumpCmResourceDescriptor (
|
|
IN PUCHAR Indent,
|
|
IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Desc
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine processes a IO_RESOURCE_DESCRIPTOR and displays it.
|
|
|
|
Arguments:
|
|
|
|
Indent - # char of indentation.
|
|
|
|
Desc - supplies a pointer to the IO_RESOURCE_DESCRIPTOR to be displayed.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
switch (Desc->Type) {
|
|
case CmResourceTypePort:
|
|
DebugPrint ((
|
|
DEBUG_RESOURCE,
|
|
"%sIO Start: %x:%08x, Length: %x\n",
|
|
Indent,
|
|
Desc->u.Port.Start.HighPart, Desc->u.Port.Start.LowPart,
|
|
Desc->u.Port.Length
|
|
));
|
|
break;
|
|
|
|
case CmResourceTypeMemory:
|
|
DebugPrint ((
|
|
DEBUG_RESOURCE,
|
|
"%sMEM Start: %x:%08x, Length: %x\n",
|
|
Indent,
|
|
Desc->u.Memory.Start.HighPart, Desc->u.Memory.Start.LowPart,
|
|
Desc->u.Memory.Length
|
|
));
|
|
break;
|
|
|
|
case CmResourceTypeInterrupt:
|
|
DebugPrint ((
|
|
DEBUG_RESOURCE,
|
|
"%sINT Level: %x, Vector: %x, Affinity: %x\n",
|
|
Indent,
|
|
Desc->u.Interrupt.Level,
|
|
Desc->u.Interrupt.Vector,
|
|
Desc->u.Interrupt.Affinity
|
|
));
|
|
break;
|
|
|
|
case CmResourceTypeDma:
|
|
DebugPrint ((
|
|
DEBUG_RESOURCE,
|
|
"%sDMA Channel: %x, Port: %x\n",
|
|
Indent,
|
|
Desc->u.Dma.Channel,
|
|
Desc->u.Dma.Port
|
|
));
|
|
break;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PipDumpCmResourceList (
|
|
IN PCM_RESOURCE_LIST CmList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine displays CM resource list.
|
|
|
|
Arguments:
|
|
|
|
CmList - supplies a pointer to CM resource list
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PCM_FULL_RESOURCE_DESCRIPTOR fullDesc;
|
|
PCM_PARTIAL_RESOURCE_LIST partialDesc;
|
|
PCM_PARTIAL_RESOURCE_DESCRIPTOR desc;
|
|
ULONG count, i;
|
|
|
|
if (CmList) {
|
|
fullDesc = &CmList->List[0];
|
|
DebugPrint((DEBUG_RESOURCE,
|
|
"Pnp Bios Cm Resource List -\n"
|
|
));
|
|
DebugPrint((DEBUG_RESOURCE,
|
|
" List Count = %x, Bus Number = %x\n",
|
|
CmList->Count, fullDesc->BusNumber
|
|
));
|
|
partialDesc = &fullDesc->PartialResourceList;
|
|
DebugPrint((DEBUG_RESOURCE,
|
|
" Version = %x, Revision = %x, Desc count = %x\n",
|
|
partialDesc->Version, partialDesc->Revision, partialDesc->Count
|
|
));
|
|
count = partialDesc->Count;
|
|
desc = &partialDesc->PartialDescriptors[0];
|
|
for (i = 0; i < count; i++) {
|
|
PipDumpCmResourceDescriptor(" ", desc);
|
|
desc++;
|
|
}
|
|
}
|
|
}
|