able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/busdrv/acpi/driver/nt/pciopregion.c

2344 lines
58 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1997 Microsoft Corporation
Module Name:
pciopregion.c
Abstract:
This module implements PCI Operational Region
support, which allows AML code to read and
write PCI configuration space.
Author:
Jake Oshins (jakeo) 7-14-97
Environment:
NT Kernel Model Driver only
--*/
#include "pch.h"
NTSTATUS
AcpiRegisterPciRegionSupport(
PDEVICE_OBJECT PciDeviceFilter
);
NTSTATUS
GetPciAddress(
IN PNSOBJ PciObj,
IN PFNACB CompletionRoutine,
IN PVOID Context,
IN OUT PUCHAR Bus,
IN OUT PPCI_SLOT_NUMBER Slot
);
NTSTATUS
EXPORT
GetPciAddressWorker(
IN PNSOBJ AcpiObject,
IN NTSTATUS Status,
IN POBJDATA Result,
IN PVOID Context
);
NTSTATUS
GetOpRegionScope(
IN PNSOBJ OpRegion,
IN PFNACB CompletionHandler,
IN PVOID CompletionContext,
OUT PNSOBJ *PciObj
);
NTSTATUS
EXPORT
GetOpRegionScopeWorker(
IN PNSOBJ AcpiObject,
IN NTSTATUS Status,
IN POBJDATA Result,
IN PVOID Context
);
UCHAR
GetBusNumberFromCRS(
IN PDEVICE_EXTENSION DeviceExtension,
IN PUCHAR CRS
);
#define MAX(a, b) \
((a) > (b) ? (a) : (b))
#define MIN(a, b) \
((a) < (b) ? (a) : (b))
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, AcpiRegisterPciRegionSupport)
#pragma alloc_text(PAGE, ACPIInitBusInterfaces)
#pragma alloc_text(PAGE, ACPIDeleteFilterInterfaceReferences)
#pragma alloc_text(PAGE, IsPciBus)
#pragma alloc_text(PAGE, IsNsobjPciBus)
#pragma alloc_text(PAGE, EnableDisableRegions)
#endif
VOID
ACPIInitBusInterfaces(
PDEVICE_OBJECT Filter
)
/*++
Routine Description:
This routine determines whether this filter is for a PCI
device. If it is, then we call AcpiRegisterPciRegionSupport.
Arguments:
Filter - device object for the filter we are looking at
Return Value:
Status
Notes:
--*/
{
PDEVICE_EXTENSION filterExt = Filter->DeviceExtension;
PDEVICE_EXTENSION parentExt;
NTSTATUS status;
PAGED_CODE();
parentExt = filterExt->ParentExtension;
if (!IsPciBus(parentExt->DeviceObject)) {
return;
}
AcpiRegisterPciRegionSupport(Filter);
}
VOID
ACPIDeleteFilterInterfaceReferences(
IN PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine is called for all filters when they are removed to see if
we need to free some interfaces
Arguments:
DeviceExtension - The device whose extension we have to dereference
Return Value:
NTSTATUS
--*/
{
AMLISUPP_CONTEXT_PASSIVE isPciDeviceContext;
BOOLEAN pciDevice;
NTSTATUS status;
PAGED_CODE();
if ( (DeviceExtension->Flags & DEV_PROP_NO_OBJECT) ) {
return;
}
KeInitializeEvent(&isPciDeviceContext.Event, SynchronizationEvent, FALSE);
isPciDeviceContext.Status = STATUS_NOT_FOUND;
status = IsPciDevice(
DeviceExtension->AcpiObject,
AmlisuppCompletePassive,
(PVOID)&isPciDeviceContext,
&pciDevice);
if (status == STATUS_PENDING) {
KeWaitForSingleObject(
&isPciDeviceContext.Event,
Executive,
KernelMode,
FALSE,
NULL);
status = isPciDeviceContext.Status;
}
if (!NT_SUCCESS(status) || !pciDevice) {
return;
}
//
// This is a PCI device, so we need to relinquish
// the interfaces that we got from the PCI driver.
//
if (!DeviceExtension->Filter.Interface) {
//
// There were no interfaces to release.
//
return;
}
//
// Dereference it.
//
DeviceExtension->Filter.Interface->InterfaceDereference(
DeviceExtension->Filter.Interface->Context
);
ExFreePool(DeviceExtension->Filter.Interface);
DeviceExtension->Filter.Interface = NULL;
}
NTSTATUS
AcpiRegisterPciRegionSupport(
PDEVICE_OBJECT PciDeviceFilter
)
/*++
Routine Description:
This routine queries the PCI driver for read and write functions
for PCI config space. It then attaches these interfaces to the
device extension for this filter. Then, if it hasn't been done
already, it registers PCI Operational Region support with the
AML interpretter.
Arguments:
PciDeviceFilter - A filter for a PCI device
Return Value:
Status
Notes:
--*/
{
PBUS_INTERFACE_STANDARD interface;
PCI_COMMON_CONFIG pciData;
NTSTATUS status;
IO_STACK_LOCATION irpSp;
PWSTR buffer;
PDEVICE_EXTENSION pciFilterExt;
PDEVICE_OBJECT topDeviceInStack;
ULONG bytes;
PAGED_CODE();
RtlZeroMemory( &irpSp, sizeof(IO_STACK_LOCATION) );
//
// If we have already registered a handler for this
// device, then we don't need to do it again.
//
pciFilterExt = PciDeviceFilter->DeviceExtension;
if (pciFilterExt->Filter.Interface) {
return STATUS_SUCCESS;
}
interface = ExAllocatePoolWithTag(NonPagedPool, sizeof(BUS_INTERFACE_STANDARD), ACPI_INTERFACE_POOLTAG);
if (!interface) {
return STATUS_INSUFFICIENT_RESOURCES;
}
topDeviceInStack = IoGetAttachedDeviceReference(pciFilterExt->TargetDeviceObject);
//
// Set the function codes and parameters.
//
irpSp.MajorFunction = IRP_MJ_PNP;
irpSp.MinorFunction = IRP_MN_QUERY_INTERFACE;
irpSp.Parameters.QueryInterface.InterfaceType = (LPGUID) &GUID_BUS_INTERFACE_STANDARD;
irpSp.Parameters.QueryInterface.Version = 1;
irpSp.Parameters.QueryInterface.Size = sizeof (BUS_INTERFACE_STANDARD);
irpSp.Parameters.QueryInterface.Interface = (PINTERFACE) interface;
irpSp.Parameters.QueryInterface.InterfaceSpecificData = NULL;
//
// Call the PCI driver.
//
status = ACPIInternalSendSynchronousIrp(topDeviceInStack,
&irpSp,
&buffer);
if (NT_SUCCESS(status)) {
//
// Attach this interface to the PCI bus PDO.
//
pciFilterExt->Filter.Interface = interface;
//
// Reference it.
//
pciFilterExt->Filter.Interface->InterfaceReference(pciFilterExt->Filter.Interface->Context);
//
// HACKHACK. The ACPI HAL doesn't really know much about busses. But
// it needs to maintain legacy HAL behavior. And to do that, it needs to
// know how many PCI busses are in the system. Since we are now looking
// at a PCI bus that we are filtering, we now give the HAL a heads-up that
// this bus exists.
//
bytes = interface->GetBusData(interface->Context,
0,
&pciData,
0,
PCI_COMMON_HDR_LENGTH);
ASSERT(bytes != 0);
if ((PCI_CONFIGURATION_TYPE((&pciData)) == PCI_BRIDGE_TYPE) ||
(PCI_CONFIGURATION_TYPE((&pciData)) == PCI_CARDBUS_BRIDGE_TYPE)) {
//
// This is actually a PCI to PCI bridge.
//
if (pciData.u.type1.SecondaryBus != 0) {
//
// And it has a bus number. So notify the HAL.
//
HalSetMaxLegacyPciBusNumber(pciData.u.type1.SecondaryBus);
}
}
} else {
ExFreePool(interface);
}
ObDereferenceObject(topDeviceInStack);
return status;
}
typedef struct {
//
// Arguments to PciConfigSpaceHandler
//
ULONG AccessType;
PNSOBJ OpRegion;
ULONG Address;
ULONG Size;
PULONG Data;
ULONG Context;
PVOID CompletionHandler;
PVOID CompletionContext;
//
// Function state
//
PNSOBJ PciObj;
PNSOBJ ParentObj;
ULONG CompletionHandlerType;
ULONG Flags;
LONG RunCompletion;
PCI_SLOT_NUMBER Slot;
UCHAR Bus;
BOOLEAN IsPciDeviceResult;
} PCI_CONFIG_STATE, *PPCI_CONFIG_STATE;
NTSTATUS
EXPORT
PciConfigSpaceHandler (
ULONG AccessType,
PNSOBJ OpRegion,
ULONG Address,
ULONG Size,
PULONG Data,
ULONG Context,
PFNAA CompletionHandler,
PVOID CompletionContext
)
/*++
Routine Description:
This routine handles requests to service the PCI operation region
Arguments:
AccessType - Read or Write data
OpRegion - Operation region object
Address - Address within PCI Configuration space
Size - Number of bytes to transfer
Data - Data buffer to transfer to/from
Context - unused
CompletionHandler - AMLI handler to call when operation is complete
CompletionContext - Context to pass to the AMLI handler
Return Value:
Status
Notes:
--*/
{
PPCI_CONFIG_STATE state;
state = ExAllocatePoolWithTag(NonPagedPool, sizeof(PCI_CONFIG_STATE), ACPI_INTERFACE_POOLTAG);
if (!state) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(state, sizeof(PCI_CONFIG_STATE));
state->AccessType = AccessType;
state->OpRegion = OpRegion;
state->Address = Address;
state->Size = Size;
state->Data = Data;
state->Context = Context;
state->CompletionHandler = CompletionHandler;
state->CompletionContext = CompletionContext;
state->PciObj = OpRegion->pnsParent;
state->RunCompletion = INITIAL_RUN_COMPLETION;
return PciConfigSpaceHandlerWorker(state->PciObj,
STATUS_SUCCESS,
NULL,
(PVOID)state);
}
typedef struct {
PCI_CONFIG_STATE HandlerState;
NSOBJ FakeOpRegion;
} PCI_INTERNAL_STATE, *PPCI_INTERNAL_STATE;
NTSTATUS
PciConfigInternal(
IN ULONG AccessType,
IN PNSOBJ PciObject,
IN ULONG Offset,
IN ULONG Length,
IN PFNACB CompletionHandler,
IN PVOID CompletionContext,
IN OUT PUCHAR Data
)
/*++
Routine Description:
This routine does PCI configuration space reads or writes.
It does the same thing as PciConfigSpaceHandler, except
that it takes an arbitrary PNSOBJ instead of an OpRegion.
Arguments:
AccessType - Read or Write data
PciObject - name space object for the PCI device
Offset - Address within PCI Configuration space
Length - Number of bytes to transfer
Context - unused
CompletionHandler - AMLI handler to call when operation is complete
CompletionContext - Context to pass to the AMLI handler
Data - Data buffer to transfer to/from
Return Value:
Status
Notes:
(1) This function is intended to be used only internally. It does
not check to see if the PNSOBJ actually represents a PCI device.
(2) This function will not allow writes to the first 0x40 bytes of
any device's PCI configuration space. This is the common area
and it is owned by the PCI driver.
--*/
{
PPCI_INTERNAL_STATE internal;
PPCI_CONFIG_STATE state;
PNSOBJ opRegion;
internal = ExAllocatePoolWithTag(NonPagedPool, sizeof(PCI_INTERNAL_STATE), ACPI_INTERFACE_POOLTAG);
if (!internal) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(internal, sizeof(PCI_INTERNAL_STATE));
internal->FakeOpRegion.Context = PciObject;
state = (PPCI_CONFIG_STATE)internal;
state->AccessType = AccessType;
state->OpRegion = &internal->FakeOpRegion;
state->Address = Offset;
state->Size = Length;
state->Data = (PULONG)Data;
state->Context = 0;
state->CompletionHandler = CompletionHandler;
state->CompletionContext = CompletionContext;
state->PciObj = PciObject;
state->CompletionHandlerType = PCISUPP_COMPLETION_HANDLER_PFNACB;
state->RunCompletion = INITIAL_RUN_COMPLETION;
return PciConfigSpaceHandlerWorker(PciObject,
STATUS_SUCCESS,
NULL,
(PVOID)state);
}
//
// This structure defines ranges in PCI configuration
// space that AML may not write. This list must be
// monotonic increasing.
//
USHORT PciOpRegionDisallowedRanges[4][2] =
{ //
// Everything below the subsystem ID registers
//
{0,0x2b},
//
// Everthing between the subsystem ID registers and
// the Max_Lat register
//
{0x30, 0x3b},
//
// Disallow anything above MAXUCHAR
//
{0x100, 0xffff},
// End tag.
{0,0}
};
NTSTATUS
EXPORT
PciConfigSpaceHandlerWorker(
IN PNSOBJ AcpiObject,
IN NTSTATUS CompletionStatus,
IN POBJDATA Result,
IN PVOID Context
)
{
PBUS_INTERFACE_STANDARD interface;
PDEVICE_EXTENSION pciDeviceFilter;
PPCI_CONFIG_STATE state;
NTSTATUS status;
ULONG range, offset, length, bytes = 0;
ULONG bytesWritten;
PFNAA simpleCompletion;
PFNACB lessSimpleCompletion;
KIRQL oldIrql;
#if DBG
BOOLEAN Complain = FALSE;
#endif
state = (PPCI_CONFIG_STATE)Context;
status = CompletionStatus;
//
// Entering this function twice with the same state
// means that we need to run the completion routine.
//
InterlockedIncrement(&state->RunCompletion);
//
// If the interpretter failed, just bail.
//
if (!NT_SUCCESS(CompletionStatus)) {
status = STATUS_SUCCESS;
#if DBG
Complain = TRUE;
#endif
goto PciConfigSpaceHandlerWorkerDone;
}
//
// If we have not seen this OpRegion before, we need to
// fill in the dwContext with the PNSOBJ of the
// PCI device which the OpRegion relates to.
//
if (!state->OpRegion->Context) {
if (!(state->Flags & PCISUPP_GOT_SCOPE)) {
state->Flags |= PCISUPP_GOT_SCOPE;
status = GetOpRegionScope(state->OpRegion,
PciConfigSpaceHandlerWorker,
(PVOID)state,
&((PNSOBJ)(state->OpRegion->Context)));
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
status = STATUS_SUCCESS;
goto PciConfigSpaceHandlerWorkerDone;
}
}
}
//
// Identify the PCI device, that device's extension,
// and the pointer to the interface within the PCI
// driver that does PCI config space reads and writes.
//
state->PciObj = (PNSOBJ)state->OpRegion->Context;
pciDeviceFilter = (PDEVICE_EXTENSION)state->PciObj->Context;
if (pciDeviceFilter == NULL) {
//
// The device has not been initialized yet, we cannot perform
// PCI config cycles to it. Fail gracefully and return all 0xFF
//
bytes = 0;
status = STATUS_SUCCESS;
goto PciConfigSpaceHandlerWorkerDone;
}
ASSERT(pciDeviceFilter);
interface = pciDeviceFilter->Filter.Interface;
ASSERT(interface ? (interface->Size == sizeof(BUS_INTERFACE_STANDARD)) : TRUE);
//
// If interface is non-zero, we have enumerated this PCI
// device. So use the PCI driver to do config ops.
// If it is zero, make some attempt to figure out what
// device this request is for. The result will be
// used in calls to the HAL.
//
if (!interface) {
if (!(state->Flags & PCISUPP_GOT_SLOT_INFO)) {
state->Flags |= PCISUPP_GOT_SLOT_INFO;
status = GetPciAddress(state->PciObj,
PciConfigSpaceHandlerWorker,
(PVOID)state,
&state->Bus,
&state->Slot);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
status = STATUS_SUCCESS;
goto PciConfigSpaceHandlerWorkerDone;
}
}
}
status = STATUS_SUCCESS;
oldIrql = KeGetCurrentIrql();
switch (state->AccessType) {
case RSACCESS_READ:
if (interface) {
//
// Do config space op through PCI driver. Do it
// at DISPATCH_LEVEL because the PCI driver expects
// that, if we are running at passive level, it can
// do things that page. Which may not be true here
// after we have powered off the disk.
//
if (oldIrql < DISPATCH_LEVEL) {
KeRaiseIrql(DISPATCH_LEVEL,
&oldIrql);
}
bytes = interface->GetBusData(interface->Context,
0,
state->Data,
state->Address,
state->Size);
if (oldIrql < DISPATCH_LEVEL) {
KeLowerIrql(oldIrql);
}
} else {
//
// Do config space op through HAL
//
bytes = HalGetBusDataByOffset(PCIConfiguration,
state->Bus,
state->Slot.u.AsULONG,
state->Data,
state->Address,
state->Size);
}
break;
case RSACCESS_WRITE:
{
static BOOLEAN ErrorLogged = FALSE;
offset = state->Address;
length = state->Size;
bytesWritten = 0;
//
// Crop any writes down to the regions that are allowed.
//
range = 0;
while (PciOpRegionDisallowedRanges[range][1] != 0) {
if (offset < PciOpRegionDisallowedRanges[range][0]) {
//
// At least part of this write falls below this
// disallowed range. Write all the data up to
// the beggining of the next allowed range.
//
length = MIN(state->Address + state->Size - offset,
PciOpRegionDisallowedRanges[range][0] - offset);
if (interface) {
if (oldIrql < DISPATCH_LEVEL) {
KeRaiseIrql(DISPATCH_LEVEL,
&oldIrql);
}
bytes = interface->SetBusData(interface->Context,
0,
(PUCHAR)(state->Data + offset - state->Address),
offset,
length);
if (oldIrql < DISPATCH_LEVEL) {
KeLowerIrql(oldIrql);
}
} else {
bytes = HalSetBusDataByOffset(PCIConfiguration,
state->Bus,
state->Slot.u.AsULONG,
(PUCHAR)(state->Data + offset - state->Address),
offset,
length);
}
//
// Keep track of what we wrote.
//
bytesWritten += length;
}
//
// Now advance offset past the end of the disallowed range.
//
offset = MAX(state->Address,
(ULONG)(PciOpRegionDisallowedRanges[range][1] + 1));
if (offset >= state->Address + state->Size) {
//
// The current possible write is beyond the end
// of the requested buffer. So we are done.
//
break;
}
range++;
}
if (bytesWritten == 0) {
if(!ErrorLogged) {
PWCHAR IllegalPCIOpRegionAddress[2];
WCHAR ACPIName[] = L"ACPI";
WCHAR addressBuffer[13];
//
// None of this write was possible. Log the problem.
//
//
// Turn the address into a string
//
swprintf( addressBuffer, L"0x%x", state->Address );
//
// Build the list of arguments to pass to the function that will write the
// error log to the registry
//
IllegalPCIOpRegionAddress[0] = ACPIName;
IllegalPCIOpRegionAddress[1] = addressBuffer;
//
// Log error to event log
//
ACPIWriteEventLogEntry(ACPI_ERR_ILLEGAL_PCIOPREGION_WRITE,
&IllegalPCIOpRegionAddress,
2,
NULL,
0
);
ErrorLogged = TRUE;
}
#if DBG
Complain = TRUE;
#endif
goto PciConfigSpaceHandlerWorkerExit;
}
bytes = bytesWritten;
break;
}
default:
status = STATUS_NOT_IMPLEMENTED;
}
PciConfigSpaceHandlerWorkerDone:
if (bytes == 0) {
//
// The handler from the HAL or the PCI driver didn't
// succeed for some reason. Fill the buffer with 0xff,
// which is what the AML will expect on failure.
//
RtlFillMemory(state->Data, state->Size, 0xff);
}
PciConfigSpaceHandlerWorkerExit:
if (state->RunCompletion) {
if (state->CompletionHandlerType ==
PCISUPP_COMPLETION_HANDLER_PFNAA) {
simpleCompletion = (PFNAA)state->CompletionHandler;
simpleCompletion(state->CompletionContext);
} else {
lessSimpleCompletion = (PFNACB)state->CompletionHandler;
lessSimpleCompletion(state->PciObj,
status,
NULL,
state->CompletionContext);
}
}
#if DBG
if ((!NT_SUCCESS(status)) || Complain) {
UCHAR opRegion[5] = {0};
UCHAR parent[5] = {0};
RtlCopyMemory(opRegion, ACPIAmliNameObject(state->OpRegion), 4);
if (state->PciObj) {
RtlCopyMemory(parent, ACPIAmliNameObject(state->PciObj), 4);
}
ACPIPrint( (
ACPI_PRINT_WARNING,
"Op Region %s failed (parent PCI device was %s)\n",
opRegion, parent
) );
}
#endif
ExFreePool(state);
return status;
}
typedef struct {
PNSOBJ PciObject;
PUCHAR Bus;
PPCI_SLOT_NUMBER Slot;
UCHAR ParentBus;
PCI_SLOT_NUMBER ParentSlot;
ULONG Flags;
ULONG Address;
ULONG BaseBusNumber;
LONG RunCompletion;
PFNACB CompletionRoutine;
PVOID CompletionContext;
} GET_ADDRESS_CONTEXT, *PGET_ADDRESS_CONTEXT;
NTSTATUS
GetPciAddress(
IN PNSOBJ PciObj,
IN PFNACB CompletionRoutine,
IN PVOID Context,
IN OUT PUCHAR Bus,
IN OUT PPCI_SLOT_NUMBER Slot
)
/*++
Routine Description:
This routine takes a PNSOBJ that represents a PCI device
and returns the Bus/Slot information for that device.
Arguments:
PciObj - PNSOBJ that represents a PCI device
CompletionRoutine - funtion to call after a STATUS_PENDING
Context - argument to the CompletionRoutine
Bus - pointer to fill in with the bus number
Slot - pointer to fill in with the slot information
Return Value:
Status
Notes:
N.B. This is not guaranteed to produce correct results.
It is intended to be used only when before the PCI
driver takes control of a device. It is a best-effort
function that will almost always work early in the
boot process.
--*/
{
PGET_ADDRESS_CONTEXT state;
ASSERT(CompletionRoutine);
state = ExAllocatePoolWithTag(NonPagedPool, sizeof(GET_ADDRESS_CONTEXT), ACPI_INTERFACE_POOLTAG);
if (!state) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(state, sizeof(GET_ADDRESS_CONTEXT));
state->PciObject = PciObj;
state->CompletionRoutine = CompletionRoutine;
state->CompletionContext = Context;
state->Bus = Bus;
state->Slot = Slot;
state->RunCompletion = INITIAL_RUN_COMPLETION;
return GetPciAddressWorker(PciObj,
STATUS_SUCCESS,
NULL,
(PVOID)state);
}
NTSTATUS
EXPORT
GetPciAddressWorker(
IN PNSOBJ AcpiObject,
IN NTSTATUS Status,
IN POBJDATA Result,
IN PVOID Context
)
{
PIO_RESOURCE_REQUIREMENTS_LIST resources;
PGET_ADDRESS_CONTEXT state;
PPCI_COMMON_CONFIG pciConfig;
NTSTATUS status;
PNSOBJ bus;
PNSOBJ tempObj;
ULONG bytesRead, i;
UCHAR buffer[PCI_COMMON_HDR_LENGTH];
ASSERT(Context);
state = (PGET_ADDRESS_CONTEXT)Context;
status = Status;
//
// Entering this function twice with the same state
// means that we need to run the completion routine.
//
InterlockedIncrement(&state->RunCompletion);
//
// If Status isn't success, then one of the worker
// functions we called puked. Bail.
//
if (!NT_SUCCESS(Status)) {
goto GetPciAddressWorkerExit;
}
//
// First, determine the slot number.
//
if (!(state->Flags & PCISUPP_CHECKED_ADR)) {
//
// Get the _ADR.
//
state->Flags |= PCISUPP_CHECKED_ADR;
status = ACPIGetNSAddressAsync(
state->PciObject,
GetPciAddressWorker,
(PVOID)state,
&(state->Address),
NULL
);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
goto GetPciAddressWorkerExit;
}
}
if (!(state->Flags & PCISUPP_GOT_SLOT_INFO)) {
//
// Build a PCI_SLOT_NUMBER out of the integer returned
// from the interpretter.
//
state->Slot->u.bits.FunctionNumber = (state->Address) & 0x7;
state->Slot->u.bits.DeviceNumber = ( (state->Address) >> 16) & 0x1f;
state->Flags |= PCISUPP_GOT_SLOT_INFO;
}
//
// Next, get the bus number, if possible.
//
*state->Bus = 0; // default value, in case we have to guess
//
// Check first to see if this bus has a _HID.
// (It might be a root PCI bridge.)
//
bus = state->PciObject;
tempObj = ACPIAmliGetNamedChild(bus, PACKED_HID);
if (!tempObj) {
//
// This device had no _HID. So look up
// to the parent and see if it is a
// root PCI bridge.
//
bus = state->PciObject->pnsParent;
tempObj = ACPIAmliGetNamedChild(bus, PACKED_HID);
}
if (!tempObj) {
//
// This PCI device is on a PCI bus that
// is created by a PCI-PCI bridge.
//
if (!(state->Flags & PCISUPP_CHECKED_PARENT)) {
state->Flags |= PCISUPP_CHECKED_PARENT;
status = GetPciAddress(
bus,
GetPciAddressWorker,
(PVOID)state,
&state->ParentBus,
&state->ParentSlot
);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
goto GetPciAddressWorkerExit;
}
}
//
// Read the config space for this device.
//
bytesRead = HalGetBusDataByOffset(PCIConfiguration,
state->ParentBus,
state->ParentSlot.u.AsULONG,
buffer,
0,
PCI_COMMON_HDR_LENGTH);
if (bytesRead == 0) {
//
// Make a guess that the bus number was 0.
//
status = STATUS_SUCCESS;
goto GetPciAddressWorkerExit;
}
pciConfig = (PPCI_COMMON_CONFIG)buffer;
if (pciConfig->HeaderType != PCI_BRIDGE_TYPE) {
//
// Make a guess that the bus number was 0.
//
status = STATUS_SUCCESS;
goto GetPciAddressWorkerExit;
}
//
// Success. Record the actual bus number of
// the secondary PCI bus and exit.
//
*state->Bus = pciConfig->u.type1.SecondaryBus;
status = STATUS_SUCCESS;
goto GetPciAddressWorkerExit;
}
//
// Is there a _BBN to run?
//
tempObj = ACPIAmliGetNamedChild(bus, PACKED_BBN);
if (tempObj) {
//
// This device must be the child of a root PCI bus.
//
if (!(state->Flags & PCISUPP_CHECKED_BBN)) {
state->Flags |= PCISUPP_CHECKED_BBN;
status = ACPIGetNSIntegerAsync(
bus,
PACKED_BBN,
GetPciAddressWorker,
(PVOID)state,
&(state->BaseBusNumber),
NULL
);
if (status == STATUS_PENDING) {
return(status);
}
if (!NT_SUCCESS(status)) {
goto GetPciAddressWorkerExit;
}
}
//
// At this point, we must have a Boot Bus Number. This is the correct
// number for this bus
//
ASSERT( state->BaseBusNumber <= 0xFF );
*(state->Bus) = (UCHAR) (state->BaseBusNumber);
//
// HACKHACK. The ACPI HAL doesn't really know much about busses. But
// it needs to maintain legacy HAL behavior. And to do that, it needs to
// know how many PCI busses are in the system. Since we just looked at
// a root PCI bus, we now give the HAL a heads-up that this bus exists.
//
HalSetMaxLegacyPciBusNumber(state->BaseBusNumber);
status = STATUS_SUCCESS;
} else {
//
// There is a no _BBN, so the bus number MUST be Zero
//
*(state->Bus) = 0;
status = STATUS_SUCCESS;
}
GetPciAddressWorkerExit:
if (state->RunCompletion) {
state->CompletionRoutine(AcpiObject,
status,
NULL,
state->CompletionContext);
}
ExFreePool(state);
return status;
}
typedef struct {
PNSOBJ AcpiObject;
ULONG Flags;
ULONG Adr;
PUCHAR Hid;
PUCHAR Cid;
BOOLEAN IsPciDeviceResult;
LONG RunCompletion;
PFNACB CompletionHandler;
PVOID CompletionContext;
BOOLEAN *Result;
} IS_PCI_DEVICE_STATE, *PIS_PCI_DEVICE_STATE;
NTSTATUS
IsPciDevice(
IN PNSOBJ AcpiObject,
IN PFNACB CompletionHandler,
IN PVOID CompletionContext,
OUT BOOLEAN *Result
)
/*++
Routine Description:
This checks to see if the PNSOBJ is a PCI device.
Arguments:
AcpiObject - the object to be checked
Result - pointer to a boolean for the result
Return Value:
Status
Notes:
--*/
{
PIS_PCI_DEVICE_STATE state;
NTSTATUS status;
state = ExAllocatePoolWithTag(NonPagedPool, sizeof(IS_PCI_DEVICE_STATE), ACPI_INTERFACE_POOLTAG);
if (!state) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(state, sizeof(IS_PCI_DEVICE_STATE));
state->AcpiObject = AcpiObject;
state->CompletionHandler = CompletionHandler;
state->CompletionContext = CompletionContext;
state->Result = Result;
state->RunCompletion = INITIAL_RUN_COMPLETION;
return IsPciDeviceWorker(AcpiObject,
STATUS_SUCCESS,
NULL,
(PVOID)state);
}
NTSTATUS
EXPORT
IsPciDeviceWorker(
IN PNSOBJ AcpiObject,
IN NTSTATUS Status,
IN POBJDATA Result,
IN PVOID Context
)
/*++
Routine Description:
This is the worker function for determining whether
or not a namespace object represents a PCI device.
The algorithm is as follows:
1) Does this device have a _HID of PNP0A03? If
so, it is a PCI device.
2) Does this device have a _CID of PNP0A03? If
so, it is a PCI device.
3) Does this device have an _ADR?
a) No, not a PCI device.
b) Yes, check to see if the parent qualifies
as a PCI device. If it does, this must
also be a PCI device. If not, then it is not.
Arguments:
AcpiObject - the object most recently under scrutiny
Status - current status
Result - OBJDATA structure necessary for worker functions
Context - pointer to the context structure
Return Value:
Status
Notes:
This function is re-entrant. It may block at any time and
return. All state is in the Context structure.
--*/
{
PIS_PCI_DEVICE_STATE state;
NTSTATUS status;
PNSOBJ hidObj;
PNSOBJ cidObj;
state = (PIS_PCI_DEVICE_STATE)Context;
status = Status;
//
// Entering this function twice with the same state
// means that we need to run the completion routine.
//
InterlockedIncrement(&state->RunCompletion);
//
// If Status isn't success, then one of the worker
// functions we called puked. Bail.
//
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciDeviceExit;
}
//
// Step 0), check to see if this is actually a "device" type
// namespace object.
//
if (NSGETOBJTYPE(state->AcpiObject) != OBJTYPE_DEVICE) {
*state->Result = FALSE;
goto IsPciDeviceExit;
}
//
// Step 1), check the _HID.
//
if (!(state->Flags & PCISUPP_CHECKED_HID)) {
state->Flags |= PCISUPP_CHECKED_HID;
state->Hid = NULL;
hidObj = ACPIAmliGetNamedChild( state->AcpiObject, PACKED_HID );
if (hidObj) {
status = ACPIGetNSPnpIDAsync(
state->AcpiObject,
IsPciDeviceWorker,
(PVOID)state,
&state->Hid,
NULL);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciDeviceExit;
}
}
}
if (state->Hid) {
if (strstr(state->Hid, PCI_PNP_ID)) {
//
// Was PCI.
//
*state->Result = TRUE;
goto IsPciDeviceExit;
}
ExFreePool(state->Hid);
state->Hid = NULL;
}
//
// Step 2), check the _CID.
//
if (!(state->Flags & PCISUPP_CHECKED_CID)) {
state->Flags |= PCISUPP_CHECKED_CID;
state->Cid = NULL;
cidObj = ACPIAmliGetNamedChild( state->AcpiObject, PACKED_CID );
if (cidObj) {
status = ACPIGetNSCompatibleIDAsync(
state->AcpiObject,
IsPciDeviceWorker,
(PVOID)state,
&state->Cid,
NULL);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciDeviceExit;
}
}
}
if (state->Cid) {
if (strstr(state->Cid, PCI_PNP_ID)) {
//
// Was PCI.
//
*state->Result = TRUE;
goto IsPciDeviceExit;
}
ExFreePool(state->Cid);
state->Cid = NULL;
}
//
// Step 3), check the _ADR.
//
if (!(state->Flags & PCISUPP_CHECKED_ADR)) {
state->Flags |= PCISUPP_CHECKED_ADR;
status = ACPIGetNSAddressAsync(
state->AcpiObject,
IsPciDeviceWorker,
(PVOID)state,
&(state->Adr),
NULL);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciDeviceExit;
}
}
//
// If we got here, it has an _ADR. Check to see if the
// parent device is a PCI device.
//
if (!(state->Flags & PCISUPP_CHECKED_PARENT)) {
state->Flags |= PCISUPP_CHECKED_PARENT;
state->IsPciDeviceResult = FALSE;
status = IsPciDevice(state->AcpiObject->pnsParent,
IsPciDeviceWorker,
(PVOID)state,
&state->IsPciDeviceResult);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciDeviceExit;
}
}
//
// Fall through to the result. If the parent was a PCI
// device, IsPciDeviceResult will now be TRUE.
//
IsPciDeviceExit:
if (state->IsPciDeviceResult) {
//
// Record the result.
//
*state->Result = state->IsPciDeviceResult;
}
if (status == STATUS_OBJECT_NAME_NOT_FOUND) {
status = STATUS_SUCCESS;
}
if (state->RunCompletion) {
state->CompletionHandler(state->AcpiObject,
status,
NULL,
state->CompletionContext);
}
if (state->Hid) ExFreePool(state->Hid);
if (state->Cid) ExFreePool(state->Cid);
ExFreePool(state);
return status;
}
typedef struct {
PNSOBJ AcpiObject;
ULONG Flags;
PUCHAR Hid;
PUCHAR Cid;
ULONG Adr;
BOOLEAN IsPciDevice;
LONG RunCompletion;
PFNACB CompletionHandler;
PVOID CompletionContext;
BOOLEAN *Result;
UCHAR Buffer[PCI_COMMON_HDR_LENGTH];
} IS_PCI_BUS_STATE, *PIS_PCI_BUS_STATE;
NTSTATUS
IsPciBusAsync(
IN PNSOBJ AcpiObject,
IN PFNACB CompletionHandler,
IN PVOID CompletionContext,
OUT BOOLEAN *Result
)
/*++
Routine Description:
This checks to see if the PNSOBJ represents a PCI bus.
Arguments:
AcpiObject - the object to be checked
Result - pointer to a boolean for the result
Return Value:
Status
Notes:
The PNSOBJ may also be a PCI device, in which case
it is a PCI to PCI bridge.
--*/
{
PIS_PCI_BUS_STATE state;
state = ExAllocatePoolWithTag(NonPagedPool, sizeof(IS_PCI_BUS_STATE), ACPI_INTERFACE_POOLTAG);
if (!state) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(state, sizeof(IS_PCI_BUS_STATE));
state->AcpiObject = AcpiObject;
state->CompletionHandler = CompletionHandler;
state->CompletionContext = CompletionContext;
state->Result = Result;
state->RunCompletion = INITIAL_RUN_COMPLETION;
*Result = FALSE;
return IsPciBusAsyncWorker(AcpiObject,
STATUS_SUCCESS,
NULL,
(PVOID)state);
}
NTSTATUS
EXPORT
IsPciBusAsyncWorker(
IN PNSOBJ AcpiObject,
IN NTSTATUS Status,
IN POBJDATA Result,
IN PVOID Context
)
{
PIS_PCI_BUS_STATE state;
PNSOBJ hidObj;
PNSOBJ cidObj;
PPCI_COMMON_CONFIG pciData;
NTSTATUS status;
ASSERT(Context);
state = (PIS_PCI_BUS_STATE)Context;
status = Status;
//
// Entering this function twice with the same state
// means that we need to run the completion routine.
//
InterlockedIncrement(&state->RunCompletion);
//
// Definitely not a PCI bus...
//
if (state->AcpiObject == NULL) {
*state->Result = FALSE;
goto IsPciBusAsyncExit;
}
//
// If Status isn't success, then one of the worker
// functions we called puked. Bail.
//
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciBusAsyncExit;
}
if (!(state->Flags & PCISUPP_CHECKED_HID)) {
state->Flags |= PCISUPP_CHECKED_HID;
state->Hid = NULL;
//
// Is there an _HID?
//
hidObj = ACPIAmliGetNamedChild( state->AcpiObject, PACKED_HID );
if (hidObj) {
status = ACPIGetNSPnpIDAsync(
state->AcpiObject,
IsPciBusAsyncWorker,
(PVOID)state,
&(state->Hid),
NULL);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciBusAsyncExit;
}
}
}
if (state->Hid) {
if (strstr(state->Hid, PCI_PNP_ID)) {
//
// Was PCI.
//
*state->Result = TRUE;
goto IsPciBusAsyncExit;
}
ExFreePool(state->Hid);
state->Hid = NULL;
}
if (!(state->Flags & PCISUPP_CHECKED_CID)) {
state->Flags |= PCISUPP_CHECKED_CID;
state->Cid = NULL;
//
// Is there a _CID?
//
cidObj = ACPIAmliGetNamedChild( state->AcpiObject, PACKED_CID );
if (cidObj) {
status = ACPIGetNSCompatibleIDAsync(
state->AcpiObject,
IsPciBusAsyncWorker,
(PVOID)state,
&(state->Cid),
NULL);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciBusAsyncExit;
}
}
}
if (state->Cid) {
if (strstr(state->Cid, PCI_PNP_ID)) {
//
// Was PCI.
//
*state->Result = TRUE;
goto IsPciBusAsyncExit;
}
ExFreePool(state->Cid);
state->Cid = NULL;
}
if (!(state->Flags & PCISUPP_CHECKED_PCI_DEVICE)) {
state->Flags |= PCISUPP_CHECKED_PCI_DEVICE;
status = IsPciDevice(state->AcpiObject,
IsPciBusAsyncWorker,
(PVOID)state,
&state->IsPciDevice);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciBusAsyncExit;
}
}
if (state->IsPciDevice) {
if (!(state->Flags & PCISUPP_CHECKED_ADR)) {
state->Flags |= PCISUPP_CHECKED_ADR;
status = ACPIGetNSAddressAsync(
state->AcpiObject,
IsPciBusAsyncWorker,
(PVOID)state,
&(state->Adr),
NULL
);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciBusAsyncExit;
}
}
if (!(state->Flags & PCISUPP_CHECKED_PCI_BRIDGE)) {
//
// Now read PCI config space to see if this is a bridge.
//
state->Flags |= PCISUPP_CHECKED_PCI_BRIDGE;
status = PciConfigInternal(RSACCESS_READ,
state->AcpiObject,
0,
PCI_COMMON_HDR_LENGTH,
IsPciBusAsyncWorker,
(PVOID)state,
state->Buffer);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
*state->Result = FALSE;
goto IsPciBusAsyncExit;
}
}
pciData = (PPCI_COMMON_CONFIG)state->Buffer;
if ((PCI_CONFIGURATION_TYPE(pciData) == PCI_BRIDGE_TYPE) ||
(PCI_CONFIGURATION_TYPE(pciData) == PCI_CARDBUS_BRIDGE_TYPE)) {
*state->Result = TRUE;
} else {
*state->Result = FALSE;
}
}
IsPciBusAsyncExit:
if (status == STATUS_OBJECT_NAME_NOT_FOUND) {
status = STATUS_SUCCESS;
}
if (state->RunCompletion) {
state->CompletionHandler(state->AcpiObject,
status,
NULL,
state->CompletionContext);
}
if (state->Hid) ExFreePool(state->Hid);
if (state->Cid) ExFreePool(state->Cid);
ExFreePool(state);
return status;
}
BOOLEAN
IsPciBus(
IN PDEVICE_OBJECT DeviceObject
)
/*++
Routine Description:
This checks to see if the DeviceObject represents a PCI bus.
Arguments:
AcpiObject - the object to be checked
Result - pointer to a boolean for the result
Return Value:
Status
Notes:
--*/
{
AMLISUPP_CONTEXT_PASSIVE getDataContext;
PDEVICE_EXTENSION devExt = ACPIInternalGetDeviceExtension(DeviceObject);
NTSTATUS status;
BOOLEAN result = FALSE;
PAGED_CODE();
ASSERT(devExt->Signature == ACPI_SIGNATURE);
KeInitializeEvent(&getDataContext.Event, SynchronizationEvent, FALSE);
getDataContext.Status = STATUS_NOT_FOUND;
if (!(devExt->Flags & DEV_PROP_NO_OBJECT) ) {
status = IsPciBusAsync( devExt->AcpiObject,
AmlisuppCompletePassive,
(PVOID)&getDataContext,
&result );
if (status == STATUS_PENDING) {
KeWaitForSingleObject(&getDataContext.Event,
Executive,
KernelMode,
FALSE,
NULL);
}
}
return result;
}
BOOLEAN
IsPciBusExtension(
IN PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This checks to see if the DeviceExtension represents a PCI bus.
Arguments:
AcpiObject - the object to be checked
Result - pointer to a boolean for the result
Return Value:
Status
Notes:
--*/
{
AMLISUPP_CONTEXT_PASSIVE getDataContext;
NTSTATUS status;
BOOLEAN result = FALSE;
PAGED_CODE();
ASSERT(DeviceExtension->Signature == ACPI_SIGNATURE);
KeInitializeEvent(&getDataContext.Event, SynchronizationEvent, FALSE);
getDataContext.Status = STATUS_NOT_FOUND;
if ( (DeviceExtension->Flags & DEV_PROP_NO_OBJECT) ) {
return result;
}
status = IsPciBusAsync(
DeviceExtension->AcpiObject,
AmlisuppCompletePassive,
(PVOID)&getDataContext,
&result
);
if (status == STATUS_PENDING) {
KeWaitForSingleObject(
&getDataContext.Event,
Executive,
KernelMode,
FALSE,
NULL
);
}
return result;
}
BOOLEAN
IsNsobjPciBus(
IN PNSOBJ Device
)
/*++
Routine Description:
This checks to see if the DeviceObject represents a PCI bus.
Arguments:
AcpiObject - the object to be checked
Result - pointer to a boolean for the result
Return Value:
Status
Notes:
--*/
{
AMLISUPP_CONTEXT_PASSIVE getDataContext;
NTSTATUS status;
BOOLEAN result = FALSE;
PAGED_CODE();
KeInitializeEvent(&getDataContext.Event, SynchronizationEvent, FALSE);
getDataContext.Status = STATUS_NOT_FOUND;
status = IsPciBusAsync( Device,
AmlisuppCompletePassive,
(PVOID)&getDataContext,
&result );
if (status == STATUS_PENDING) {
KeWaitForSingleObject(&getDataContext.Event,
Executive,
KernelMode,
FALSE,
NULL);
status = getDataContext.Status;
}
return result;
}
typedef struct {
PNSOBJ OpRegion;
PNSOBJ Parent;
ULONG Flags;
BOOLEAN IsPciDeviceResult;
LONG RunCompletion;
PFNACB CompletionHandler;
PVOID CompletionContext;
PNSOBJ *PciObj;
} OP_REGION_SCOPE_STATE, *POP_REGION_SCOPE_STATE;
NTSTATUS
GetOpRegionScope(
IN PNSOBJ OpRegion,
IN PFNACB CompletionHandler,
IN PVOID CompletionContext,
OUT PNSOBJ *PciObj
)
/*++
Routine Description:
This routine takes a pointer to an OpRegion and
returns a pointer to the PCI device that it operates
on.
Arguments:
OpRegion - the operational region
PciObj - the object the region operates on
Return Value:
Status
Notes:
--*/
{
POP_REGION_SCOPE_STATE state;
state = ExAllocatePoolWithTag(NonPagedPool, sizeof(OP_REGION_SCOPE_STATE), ACPI_INTERFACE_POOLTAG);
if (!state) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(state, sizeof(OP_REGION_SCOPE_STATE));
state->OpRegion = OpRegion;
state->Parent = OpRegion->pnsParent;
state->CompletionHandler = CompletionHandler;
state->CompletionContext = CompletionContext;
state->PciObj = PciObj;
state->RunCompletion = INITIAL_RUN_COMPLETION;
return GetOpRegionScopeWorker(OpRegion,
STATUS_SUCCESS,
NULL,
(PVOID)state);
}
NTSTATUS
EXPORT
GetOpRegionScopeWorker(
IN PNSOBJ AcpiObject,
IN NTSTATUS Status,
IN POBJDATA Result,
IN PVOID Context
)
{
POP_REGION_SCOPE_STATE state;
NTSTATUS status;
BOOLEAN found = FALSE;
ASSERT(Context);
state = (POP_REGION_SCOPE_STATE)Context;
status = Status;
//
// Entering this function twice with the same state
// means that we need to run the completion routine.
//
InterlockedIncrement(&state->RunCompletion);
if (!NT_SUCCESS(Status)) {
goto GetOpRegionScopeWorkerExit;
}
//
// Need to find the PNSOBJ for the PCI device. Do it by
// looking up the tree.
//
while ((state->Parent != NULL) &&
(state->Parent->pnsParent != state->Parent)) {
if ( !(state->Flags & PCISUPP_COMPLETING_IS_PCI) ) {
state->Flags |= PCISUPP_COMPLETING_IS_PCI;
status = IsPciDevice(state->Parent,
GetOpRegionScopeWorker,
(PVOID)state,
&state->IsPciDeviceResult);
if (status == STATUS_PENDING) {
return status;
}
if (!NT_SUCCESS(status)) {
goto GetOpRegionScopeWorkerExit;
}
}
state->Flags &= ~PCISUPP_COMPLETING_IS_PCI;
if (state->IsPciDeviceResult) {
found = TRUE;
break;
}
//
// Look one step higher.
//
state->Parent = state->Parent->pnsParent;
}
if (found) {
*state->PciObj = state->Parent;
status = STATUS_SUCCESS;
} else {
status = STATUS_NOT_FOUND;
}
GetOpRegionScopeWorkerExit:
if (state->RunCompletion) {
state->CompletionHandler(state->OpRegion,
status,
NULL,
state->CompletionContext);
}
ExFreePool(state);
return status;
}
NTSTATUS
EnableDisableRegions(
IN PNSOBJ NameSpaceObj,
IN BOOLEAN Enable
)
/*++
Routine Description:
This routine runs the _REG method for all PCI op-regions
underneath NameSpaceObj and all its children, except
additional PCI to PCI bridges.
Arguments:
NameSpaceObj - A device in the namespace
Enable - boolean specifying whether this function should
enable or disable the regions
Return Value:
Status
Notes:
--*/
#define CONNECT_HANDLER 1
#define DISCONNECT_HANDLER 0
{
PNSOBJ sibling;
PNSOBJ regMethod = NULL;
OBJDATA objdata[2];
NTSTATUS status, returnStatus;
PAGED_CODE();
ASSERT(NameSpaceObj->dwNameSeg);
//
// Find a _REG that is a child of this device.
//
regMethod = ACPIAmliGetNamedChild( NameSpaceObj, PACKED_REG );
if (regMethod != NULL) {
//
// Construct arguments for _REG method.
//
RtlZeroMemory(objdata, sizeof(objdata));
objdata[0].dwDataType = OBJTYPE_INTDATA;
objdata[0].uipDataValue = REGSPACE_PCICFG;
objdata[1].dwDataType = OBJTYPE_INTDATA;
objdata[1].uipDataValue = (Enable ? CONNECT_HANDLER : DISCONNECT_HANDLER );
status = AMLIEvalNameSpaceObject(
regMethod,
NULL,
2,
objdata
);
}
//
// Recurse to all of the children. Propagate any errors,
// but don't stop for them.
//
returnStatus = STATUS_SUCCESS;
sibling = NSGETFIRSTCHILD(NameSpaceObj);
if (!sibling) {
return returnStatus;
}
do {
switch (NSGETOBJTYPE(sibling)) {
case OBJTYPE_DEVICE:
if (IsNsobjPciBus(sibling)) {
//
// Don't recurse past a child PCI to PCI bridge.
//
break;
}
status = EnableDisableRegions(sibling, Enable);
if (!NT_SUCCESS(status)) {
returnStatus = status;
}
break;
default:
break;
}
} while (sibling = NSGETNEXTSIBLING(sibling));
return returnStatus;
}
UCHAR
GetBusNumberFromCRS(
IN PDEVICE_EXTENSION DeviceExtension,
IN PUCHAR CRS
)
/*++
Routine Description:
Grovels through the _CRS buffer looking for an address
descriptor for the bus number
Arguments:
DeviceExtension - Pointer to the PCI root bus
CRS - Supplies the CRS.
Return Value:
NTSTATUS
--*/
{
PPNP_DWORD_ADDRESS_DESCRIPTOR DwordAddress;
PPNP_QWORD_ADDRESS_DESCRIPTOR QwordAddress;
PPNP_WORD_ADDRESS_DESCRIPTOR WordAddress;
PUCHAR Current;
UCHAR TagName;
USHORT Increment;
Current = CRS;
while ( *Current ) {
TagName = *Current;
if ( !(TagName & LARGE_RESOURCE_TAG)) {
Increment = (USHORT) (TagName & SMALL_TAG_SIZE_MASK) + 1;
TagName &= SMALL_TAG_MASK;
} else {
Increment = ( *(USHORT UNALIGNED *)(Current + 1) ) + 3;
}
if (TagName == TAG_END) {
break;
}
switch(TagName) {
case TAG_DOUBLE_ADDRESS:
DwordAddress = (PPNP_DWORD_ADDRESS_DESCRIPTOR) Current;
if (DwordAddress->RFlag == PNP_ADDRESS_BUS_NUMBER_TYPE) {
ASSERT(DwordAddress->MinimumAddress <= 0xFF);
return (UCHAR) DwordAddress->MinimumAddress;
}
break;
case TAG_QUAD_ADDRESS:
QwordAddress = (PPNP_QWORD_ADDRESS_DESCRIPTOR) Current;
if (QwordAddress->RFlag == PNP_ADDRESS_BUS_NUMBER_TYPE) {
ASSERT(QwordAddress->MinimumAddress <= 0xFF);
return (UCHAR) QwordAddress->MinimumAddress;
}
break;
case TAG_WORD_ADDRESS:
WordAddress = (PPNP_WORD_ADDRESS_DESCRIPTOR) Current;
if (WordAddress->RFlag == PNP_ADDRESS_BUS_NUMBER_TYPE) {
ASSERT(WordAddress->MinimumAddress <= 0xFF);
return (UCHAR) WordAddress->MinimumAddress;
}
break;
}
Current += Increment;
}
//
// No Bus address was found. This is an error in the BIOS.
//
KeBugCheckEx(
ACPI_BIOS_ERROR,
ACPI_ROOT_PCI_RESOURCE_FAILURE,
(ULONG_PTR) DeviceExtension,
3,
(ULONG_PTR) CRS
);
return((UCHAR)-1);
}
Reference in a new issue Copy permalink