acpisys.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_COMMON_DEVICE_DATA
struct	_PDO_DEVICE_DATA
struct	_FDO_DEVICE_DATA

Macros
#define	FDO_FROM_PDO(pdoData)   ((PFDO_DEVICE_DATA) (pdoData)->ParentFdo->DeviceExtension)
#define	INITIALIZE_PNP_STATE(_Data_)
#define	SET_NEW_PNP_STATE(_Data_, _state_)
#define	RESTORE_PREVIOUS_PNP_STATE(_Data_)   (_Data_).DevicePnPState = (_Data_).PreviousPnPState;\

Typedefs
typedef enum _DEVICE_PNP_STATE	DEVICE_PNP_STATE
typedef struct _COMMON_DEVICE_DATA	COMMON_DEVICE_DATA
typedef struct _COMMON_DEVICE_DATA *	PCOMMON_DEVICE_DATA
typedef struct _PDO_DEVICE_DATA	PDO_DEVICE_DATA
typedef struct _PDO_DEVICE_DATA *	PPDO_DEVICE_DATA
typedef struct _FDO_DEVICE_DATA	FDO_DEVICE_DATA
typedef struct _FDO_DEVICE_DATA *	PFDO_DEVICE_DATA

Enumerations
enum	_DEVICE_PNP_STATE {   NotStarted = 0, Started, StopPending, Stopped,   RemovalPending, UnKnown }

Functions
NTSTATUS	ACPIEnumerateDevices (PFDO_DEVICE_DATA DeviceExtension)
NTSTATUS NTAPI	Bus_PDO_EvalMethod (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
NTSTATUS NTAPI	Bus_CreateClose (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	Bus_DriverUnload (PDRIVER_OBJECT DriverObject)
PCHAR	PnPMinorFunctionString (UCHAR MinorFunction)
NTSTATUS NTAPI	Bus_AddDevice (PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS	Bus_SendIrpSynchronously (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	Bus_PnP (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	Bus_CompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
VOID	Bus_InitializePdo (PDEVICE_OBJECT Pdo, PFDO_DEVICE_DATA FdoData)
void	Bus_RemoveFdo (PFDO_DEVICE_DATA FdoData)
NTSTATUS	Bus_DestroyPdo (PDEVICE_OBJECT Device, PPDO_DEVICE_DATA PdoData)
NTSTATUS	Bus_FDO_PnP (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpStack, PFDO_DEVICE_DATA DeviceData)
NTSTATUS	Bus_StartFdo (PFDO_DEVICE_DATA FdoData, PIRP Irp)
PCHAR	DbgDeviceIDString (BUS_QUERY_ID_TYPE Type)
PCHAR	DbgDeviceRelationString (DEVICE_RELATION_TYPE Type)
NTSTATUS	Bus_FDO_Power (PFDO_DEVICE_DATA FdoData, PIRP Irp)
NTSTATUS	Bus_PDO_Power (PPDO_DEVICE_DATA PdoData, PIRP Irp)
NTSTATUS NTAPI	Bus_Power (PDEVICE_OBJECT DeviceObject, PIRP Irp)
PCHAR	PowerMinorFunctionString (UCHAR MinorFunction)
PCHAR	DbgSystemPowerString (SYSTEM_POWER_STATE Type)
PCHAR	DbgDevicePowerString (DEVICE_POWER_STATE Type)
NTSTATUS	Bus_PDO_PnP (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpStack, PPDO_DEVICE_DATA DeviceData)
NTSTATUS	Bus_PDO_QueryDeviceCaps (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
NTSTATUS	Bus_PDO_QueryDeviceId (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
NTSTATUS	Bus_PDO_QueryDeviceText (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
NTSTATUS	Bus_PDO_QueryResources (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
NTSTATUS	Bus_PDO_QueryResourceRequirements (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
NTSTATUS	Bus_PDO_QueryDeviceRelations (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
NTSTATUS	Bus_PDO_QueryBusInformation (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
NTSTATUS	Bus_GetDeviceCapabilities (PDEVICE_OBJECT DeviceObject, PDEVICE_CAPABILITIES DeviceCapabilities)
NTSTATUS	Bus_PDO_QueryInterface (PPDO_DEVICE_DATA DeviceData, PIRP Irp)
BOOLEAN	Bus_GetCrispinessLevel (PVOID Context, PUCHAR Level)
BOOLEAN	Bus_SetCrispinessLevel (PVOID Context, UCHAR Level)
BOOLEAN	Bus_IsSafetyLockEnabled (PVOID Context)
VOID	Bus_InterfaceReference (PVOID Context)
VOID	Bus_InterfaceDereference (PVOID Context)

Variables
UNICODE_STRING	ProcessorHardwareIds
LPWSTR	ProcessorIdString
LPWSTR	ProcessorNameString

Macro Definition Documentation

FDO_FROM_PDO

#define FDO_FROM_PDO

(

pdoData

)

((PFDO_DEVICE_DATA) (pdoData)->ParentFdo->DeviceExtension)

Definition at line 76 of file acpisys.h.

INITIALIZE_PNP_STATE

#define INITIALIZE_PNP_STATE

(

_Data_

)

Value:

(_Data_).DevicePnPState =  NotStarted;\
        (_Data_).PreviousPnPState = NotStarted;

Definition at line 79 of file acpisys.h.

RESTORE_PREVIOUS_PNP_STATE

#define RESTORE_PREVIOUS_PNP_STATE

(

_Data_

)

(_Data_).DevicePnPState = (_Data_).PreviousPnPState;\

Definition at line 87 of file acpisys.h.

SET_NEW_PNP_STATE

#define SET_NEW_PNP_STATE	(		_Data_,
			_state_
	)

Value:

(_Data_).PreviousPnPState =  (_Data_).DevicePnPState;\
        (_Data_).DevicePnPState = (_state_);

Definition at line 83 of file acpisys.h.

Typedef Documentation

COMMON_DEVICE_DATA

typedef struct _COMMON_DEVICE_DATA COMMON_DEVICE_DATA

DEVICE_PNP_STATE

typedef enum _DEVICE_PNP_STATE DEVICE_PNP_STATE

FDO_DEVICE_DATA

typedef struct _FDO_DEVICE_DATA FDO_DEVICE_DATA

PCOMMON_DEVICE_DATA

typedef struct _COMMON_DEVICE_DATA * PCOMMON_DEVICE_DATA

PDO_DEVICE_DATA

typedef struct _PDO_DEVICE_DATA PDO_DEVICE_DATA

PFDO_DEVICE_DATA

typedef struct _FDO_DEVICE_DATA * PFDO_DEVICE_DATA

PPDO_DEVICE_DATA

typedef struct _PDO_DEVICE_DATA * PPDO_DEVICE_DATA

Enumeration Type Documentation

_DEVICE_PNP_STATE

enum _DEVICE_PNP_STATE

Enumerator
NotStarted
Started
StopPending
Stopped
RemovalPending
UnKnown

Definition at line 11 of file acpisys.h.

                               {

    NotStarted = 0,         // Not started yet
    Started,                // Device has received the START_DEVICE IRP
    StopPending,            // Device has received the QUERY_STOP IRP
    Stopped,                // Device has received the STOP_DEVICE IRP
    RemovalPending,         // Device has received the QUERY_REMOVE IRP
    UnKnown                 // Unknown state

} DEVICE_PNP_STATE;

Function Documentation

ACPIEnumerateDevices()

NTSTATUS ACPIEnumerateDevices

(

PFDO_DEVICE_DATA

DeviceExtension

)

Definition at line 146 of file acpienum.c.

{
    ULONG Count = 0;
    struct acpi_device *Device = acpi_root;

    while(Device)
    {
        if (Device->status.present && Device->status.enabled &&
            Device->flags.hardware_id)
        {
            Bus_PlugInDevice(Device, DeviceExtension);
            Count++;
        }

        if (HAS_CHILDREN(Device)) {
            Device = NODE_TO_DEVICE(Device->children.next);
            continue;
        }
        if (HAS_SIBLINGS(Device)) {
            Device = NODE_TO_DEVICE(Device->node.next);
            continue;
        }
        while ((Device = Device->parent)) {
            if (HAS_SIBLINGS(Device)) {
                Device = NODE_TO_DEVICE(Device->node.next);
                break;
            }
        }
    }
    DPRINT("acpi device count: %d\n", Count);
    return STATUS_SUCCESS;
}

Referenced by Bus_StartFdo().

Bus_AddDevice()

NTSTATUS NTAPI Bus_AddDevice	(	PDRIVER_OBJECT	DriverObject,
		PDEVICE_OBJECT	PhysicalDeviceObject
	)

Definition at line 31 of file main.c.

{
    NTSTATUS            status;
    PDEVICE_OBJECT      deviceObject = NULL;
    PFDO_DEVICE_DATA    deviceData = NULL;
#ifndef NDEBUG
    PWCHAR              deviceName = NULL;
    ULONG               nameLength;
#endif

    PAGED_CODE ();

    DPRINT("Add Device: 0x%p\n",  PhysicalDeviceObject);

    DPRINT("#################### Bus_CreateClose Creating FDO Device ####################\n");
    status = IoCreateDevice(DriverObject,
                      sizeof(FDO_DEVICE_DATA),
                      NULL,
                      FILE_DEVICE_ACPI,
                      FILE_DEVICE_SECURE_OPEN,
                      TRUE,
                      &deviceObject);
    if (!NT_SUCCESS(status))
    {
        DPRINT1("IoCreateDevice() failed with status 0x%X\n", status);
        goto End;
    }

    deviceData = (PFDO_DEVICE_DATA) deviceObject->DeviceExtension;
    RtlZeroMemory (deviceData, sizeof (FDO_DEVICE_DATA));

    //
    // Set the initial state of the FDO
    //

    INITIALIZE_PNP_STATE(deviceData->Common);

    deviceData->Common.IsFDO = TRUE;

    deviceData->Common.Self = deviceObject;

    ExInitializeFastMutex (&deviceData->Mutex);

    InitializeListHead (&deviceData->ListOfPDOs);

    // Set the PDO for use with PlugPlay functions

    deviceData->UnderlyingPDO = PhysicalDeviceObject;

    //
    // Set the initial powerstate of the FDO
    //

    deviceData->Common.DevicePowerState = PowerDeviceUnspecified;
    deviceData->Common.SystemPowerState = PowerSystemWorking;

    deviceObject->Flags |= DO_POWER_PAGABLE;

    //
    // Attach our FDO to the device stack.
    // The return value of IoAttachDeviceToDeviceStack is the top of the
    // attachment chain.  This is where all the IRPs should be routed.
    //

    deviceData->NextLowerDriver = IoAttachDeviceToDeviceStack (
                                    deviceObject,
                                    PhysicalDeviceObject);

    if (NULL == deviceData->NextLowerDriver) {

        status = STATUS_NO_SUCH_DEVICE;
        goto End;
    }


#ifndef NDEBUG
    //
    // We will demonstrate here the step to retrieve the name of the PDO
    //

    status = IoGetDeviceProperty (PhysicalDeviceObject,
                                  DevicePropertyPhysicalDeviceObjectName,
                                  0,
                                  NULL,
                                  &nameLength);

    if (status != STATUS_BUFFER_TOO_SMALL)
    {
        DPRINT1("AddDevice:IoGDP failed (0x%x)\n", status);
        goto End;
    }

    deviceName = ExAllocatePoolWithTag(NonPagedPool, nameLength, 'MpcA');

    if (NULL == deviceName) {
        DPRINT1("AddDevice: no memory to alloc for deviceName(0x%x)\n", nameLength);
        status =  STATUS_INSUFFICIENT_RESOURCES;
        goto End;
    }

    status = IoGetDeviceProperty (PhysicalDeviceObject,
                         DevicePropertyPhysicalDeviceObjectName,
                         nameLength,
                         deviceName,
                         &nameLength);

    if (!NT_SUCCESS (status)) {

        DPRINT1("AddDevice:IoGDP(2) failed (0x%x)", status);
        goto End;
    }

    DPRINT("AddDevice: %p to %p->%p (%ws) \n",
                   deviceObject,
                   deviceData->NextLowerDriver,
                   PhysicalDeviceObject,
                   deviceName);

#endif

    //
    // We are done with initializing, so let's indicate that and return.
    // This should be the final step in the AddDevice process.
    //
    deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

End:
#ifndef NDEBUG
    if (deviceName){
        ExFreePoolWithTag(deviceName, 'MpcA');
    }
#endif
    if (!NT_SUCCESS(status) && deviceObject){
        if (deviceData && deviceData->NextLowerDriver){
            IoDetachDevice (deviceData->NextLowerDriver);
        }
        IoDeleteDevice (deviceObject);
    }
    return status;

}

Referenced by DriverEntry().

Bus_CompletionRoutine()

NTSTATUS NTAPI Bus_CompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 369 of file pnp.c.

{
    UNREFERENCED_PARAMETER (DeviceObject);

    //
    // If the lower driver didn't return STATUS_PENDING, we don't need to
    // set the event because we won't be waiting on it.
    // This optimization avoids grabbing the dispatcher lock and improves perf.
    //
    if (Irp->PendingReturned != FALSE) {

        KeSetEvent ((PKEVENT) Context, IO_NO_INCREMENT, FALSE);
    }
    return STATUS_MORE_PROCESSING_REQUIRED; // Keep this IRP
}

Referenced by Bus_SendIrpSynchronously().

Bus_CreateClose()

NTSTATUS NTAPI Bus_CreateClose	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Bus_DestroyPdo()

NTSTATUS Bus_DestroyPdo	(	PDEVICE_OBJECT	Device,
		PPDO_DEVICE_DATA	PdoData
	)

Definition at line 390 of file pnp.c.

{
    PAGED_CODE ();

    //
    // BusEnum does not queue any irps at this time so we have nothing to do.
    //

    //
    // Free any resources.
    //

    if (PdoData->HardwareIDs) {
        ExFreePoolWithTag(PdoData->HardwareIDs, 'DpcA');
        PdoData->HardwareIDs = NULL;
    }

    DPRINT("\tDeleting PDO: 0x%p\n", Device);
    IoDeleteDevice (Device);
    return STATUS_SUCCESS;
}

Bus_DriverUnload()

VOID Bus_DriverUnload

(

PDRIVER_OBJECT

DriverObject

)

Bus_FDO_PnP()

NTSTATUS Bus_FDO_PnP	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PIO_STACK_LOCATION	IrpStack,
		PFDO_DEVICE_DATA	DeviceData
	)

Definition at line 72 of file pnp.c.

{
    NTSTATUS            status;
    ULONG               length, prevcount, numPdosPresent;
    PLIST_ENTRY         entry;
    PPDO_DEVICE_DATA    pdoData;
    PDEVICE_RELATIONS   relations, oldRelations;

    PAGED_CODE ();

    switch (IrpStack->MinorFunction) {

    case IRP_MN_START_DEVICE:

        status = Bus_StartFdo (DeviceData, Irp);


        //
        // We must now complete the IRP, since we stopped it in the
        // completion routine with MORE_PROCESSING_REQUIRED.
        //

        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);

        return status;

    case IRP_MN_QUERY_STOP_DEVICE:

        //
        // The PnP manager is trying to stop the device
        // for resource rebalancing.
        //
        SET_NEW_PNP_STATE(DeviceData->Common, StopPending);
        Irp->IoStatus.Status = STATUS_SUCCESS;
        break;

    case IRP_MN_CANCEL_STOP_DEVICE:

        //
        // The PnP Manager sends this IRP, at some point after an
        // IRP_MN_QUERY_STOP_DEVICE, to inform the drivers for a
        // device that the device will not be stopped for
        // resource reconfiguration.
        //
        //
        // First check to see whether you have received cancel-stop
        // without first receiving a query-stop. This could happen if
        //  someone above us fails a query-stop and passes down the subsequent
        // cancel-stop.
        //

        if (StopPending == DeviceData->Common.DevicePnPState)
        {
            //
            // We did receive a query-stop, so restore.
            //
            RESTORE_PREVIOUS_PNP_STATE(DeviceData->Common);
            ASSERT(DeviceData->Common.DevicePnPState == Started);
        }
        Irp->IoStatus.Status = STATUS_SUCCESS; // We must not fail the IRP.
        break;

    case IRP_MN_QUERY_DEVICE_RELATIONS:

        DPRINT("\tQueryDeviceRelation Type: %s\n",
                    DbgDeviceRelationString(\
                    IrpStack->Parameters.QueryDeviceRelations.Type));

        if (BusRelations != IrpStack->Parameters.QueryDeviceRelations.Type) {
            //
            // We don't support any other Device Relations
            //
            break;
        }


        ExAcquireFastMutex (&DeviceData->Mutex);

        oldRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information;
        if (oldRelations) {
            prevcount = oldRelations->Count;
            if (!DeviceData->NumPDOs) {
                //
                // There is a device relations struct already present and we have
                // nothing to add to it, so just call IoSkip and IoCall
                //
                ExReleaseFastMutex (&DeviceData->Mutex);
                break;
            }
        }
        else  {
            prevcount = 0;
        }

        //
        // Calculate the number of PDOs actually present on the bus
        //
        numPdosPresent = 0;
        for (entry = DeviceData->ListOfPDOs.Flink;
             entry != &DeviceData->ListOfPDOs;
             entry = entry->Flink) {
            pdoData = CONTAINING_RECORD (entry, PDO_DEVICE_DATA, Link);
            numPdosPresent++;
        }

        //
        // Need to allocate a new relations structure and add our
        // PDOs to it.
        //

        length = sizeof(DEVICE_RELATIONS) +
                (((numPdosPresent + prevcount) - 1) * sizeof (PDEVICE_OBJECT));

        relations = ExAllocatePoolWithTag(PagedPool, length, 'IpcA');

        if (NULL == relations) {
            //
            // Fail the IRP
            //
            ExReleaseFastMutex (&DeviceData->Mutex);
            Irp->IoStatus.Status = status = STATUS_INSUFFICIENT_RESOURCES;
            IoCompleteRequest (Irp, IO_NO_INCREMENT);
            return status;

        }

        //
        // Copy in the device objects so far
        //
        if (prevcount) {
            RtlCopyMemory (relations->Objects, oldRelations->Objects,
                                      prevcount * sizeof (PDEVICE_OBJECT));
        }

        relations->Count = prevcount + numPdosPresent;

        //
        // For each PDO present on this bus add a pointer to the device relations
        // buffer, being sure to take out a reference to that object.
        // The Plug & Play system will dereference the object when it is done
        // with it and free the device relations buffer.
        //

        for (entry = DeviceData->ListOfPDOs.Flink;
             entry != &DeviceData->ListOfPDOs;
             entry = entry->Flink) {

            pdoData = CONTAINING_RECORD (entry, PDO_DEVICE_DATA, Link);
            relations->Objects[prevcount] = pdoData->Common.Self;
            ObReferenceObject (pdoData->Common.Self);
            prevcount++;
        }

        DPRINT("\t#PDOs present = %d\n\t#PDOs reported = %d\n",
                             DeviceData->NumPDOs, relations->Count);

        //
        // Replace the relations structure in the IRP with the new
        // one.
        //
        if (oldRelations) {
            ExFreePoolWithTag(oldRelations, 0);
        }
        Irp->IoStatus.Information = (ULONG_PTR) relations;

        ExReleaseFastMutex (&DeviceData->Mutex);

        //
        // Set up and pass the IRP further down the stack
        //
        Irp->IoStatus.Status = STATUS_SUCCESS;
        break;

    default:

        //
        // In the default case we merely call the next driver.
        // We must not modify Irp->IoStatus.Status or complete the IRP.
        //

        break;
    }

    IoSkipCurrentIrpStackLocation (Irp);
    status = IoCallDriver (DeviceData->NextLowerDriver, Irp);
    return STATUS_SUCCESS;
}

Referenced by Bus_PnP().

Bus_FDO_Power()

NTSTATUS Bus_FDO_Power	(	PFDO_DEVICE_DATA	FdoData,
		PIRP	Irp
	)

Definition at line 49 of file power.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
    POWER_STATE         powerState;
    POWER_STATE_TYPE    powerType;
    PIO_STACK_LOCATION  stack;
    ULONG AcpiState;
    ACPI_STATUS AcpiStatus;
    SYSTEM_POWER_STATE  oldPowerState;

    stack = IoGetCurrentIrpStackLocation (Irp);
    powerType = stack->Parameters.Power.Type;
    powerState = stack->Parameters.Power.State;


    if (stack->MinorFunction == IRP_MN_SET_POWER) {
        DPRINT("\tRequest to set %s state to %s\n",
               ((powerType == SystemPowerState) ?  "System" : "Device"),
               ((powerType == SystemPowerState) ? \
               DbgSystemPowerString(powerState.SystemState) :\
               DbgDevicePowerString(powerState.DeviceState)));

  if (powerType == SystemPowerState)
  {
    switch (powerState.SystemState) {
    case PowerSystemSleeping1:
      AcpiState = ACPI_STATE_S1;
      break;
    case PowerSystemSleeping2:
      AcpiState = ACPI_STATE_S2;
      break;
    case PowerSystemSleeping3:
      AcpiState = ACPI_STATE_S3;
      break;
    case PowerSystemHibernate:
      AcpiState = ACPI_STATE_S4;
      break;
    case PowerSystemShutdown:
      AcpiState = ACPI_STATE_S5;
      break;
    default:
      AcpiState = ACPI_STATE_UNKNOWN;
      ASSERT(FALSE);
      break;
    }
      oldPowerState = Data->Common.SystemPowerState;
      Data->Common.SystemPowerState = powerState.SystemState;
      AcpiStatus = acpi_suspend(AcpiState);
      if (!ACPI_SUCCESS(AcpiStatus)) {
        DPRINT1("Failed to enter sleep state %d (Status 0x%X)\n",
          AcpiState, AcpiStatus);
        Data->Common.SystemPowerState = oldPowerState;
        status = STATUS_UNSUCCESSFUL;
      }
  }
    }
    PoStartNextPowerIrp (Irp);
    IoSkipCurrentIrpStackLocation(Irp);
    status =  PoCallDriver (Data->NextLowerDriver, Irp);
    return status;
}

Referenced by Bus_Power().

Bus_GetCrispinessLevel()

BOOLEAN Bus_GetCrispinessLevel	(	PVOID	Context,
		PUCHAR	Level
	)

Bus_GetDeviceCapabilities()

NTSTATUS Bus_GetDeviceCapabilities	(	PDEVICE_OBJECT	DeviceObject,
		PDEVICE_CAPABILITIES	DeviceCapabilities
	)

Definition at line 1961 of file buspdo.c.

{
    IO_STATUS_BLOCK     ioStatus;
    KEVENT              pnpEvent;
    NTSTATUS            status;
    PDEVICE_OBJECT      targetObject;
    PIO_STACK_LOCATION  irpStack;
    PIRP                pnpIrp;

    PAGED_CODE();

    //
    // Initialize the capabilities that we will send down
    //
    RtlZeroMemory( DeviceCapabilities, sizeof(DEVICE_CAPABILITIES) );
    DeviceCapabilities->Size = sizeof(DEVICE_CAPABILITIES);
    DeviceCapabilities->Version = 1;
    DeviceCapabilities->Address = -1;
    DeviceCapabilities->UINumber = -1;

    //
    // Initialize the event
    //
    KeInitializeEvent( &pnpEvent, NotificationEvent, FALSE );

    targetObject = IoGetAttachedDeviceReference( DeviceObject );

    //
    // Build an Irp
    //
    pnpIrp = IoBuildSynchronousFsdRequest(
        IRP_MJ_PNP,
        targetObject,
        NULL,
        0,
        NULL,
        &pnpEvent,
        &ioStatus
        );
    if (pnpIrp == NULL) {

        status = STATUS_INSUFFICIENT_RESOURCES;
        goto GetDeviceCapabilitiesExit;

    }

    //
    // Pnp Irps all begin life as STATUS_NOT_SUPPORTED;
    //
    pnpIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;

    //
    // Get the top of stack
    //
    irpStack = IoGetNextIrpStackLocation( pnpIrp );

    //
    // Set the top of stack
    //
    RtlZeroMemory( irpStack, sizeof(IO_STACK_LOCATION ) );
    irpStack->MajorFunction = IRP_MJ_PNP;
    irpStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
    irpStack->Parameters.DeviceCapabilities.Capabilities = DeviceCapabilities;

    //
    // Call the driver
    //
    status = IoCallDriver( targetObject, pnpIrp );
    if (status == STATUS_PENDING) {

        //
        // Block until the irp comes back.
        // Important thing to note here is when you allocate
        // the memory for an event in the stack you must do a
        // KernelMode wait instead of UserMode to prevent
        // the stack from getting paged out.
        //

        KeWaitForSingleObject(
            &pnpEvent,
            Executive,
            KernelMode,
            FALSE,
            NULL
            );
        status = ioStatus.Status;

    }

GetDeviceCapabilitiesExit:
    //
    // Done with reference
    //
    ObDereferenceObject( targetObject );

    //
    // Done
    //
    return status;

}

Bus_InitializePdo()

VOID Bus_InitializePdo	(	PDEVICE_OBJECT	Pdo,
		PFDO_DEVICE_DATA	FdoData
	)

Definition at line 417 of file pnp.c.

{
    PPDO_DEVICE_DATA pdoData;
    int acpistate;
    DEVICE_POWER_STATE ntState;

    PAGED_CODE ();

    pdoData = (PPDO_DEVICE_DATA)  Pdo->DeviceExtension;

    DPRINT("pdo 0x%p, extension 0x%p\n", Pdo, pdoData);

    if (pdoData->AcpiHandle)
        acpi_bus_get_power(pdoData->AcpiHandle, &acpistate);
    else
        acpistate = ACPI_STATE_D0;

    switch(acpistate)
    {
        case ACPI_STATE_D0:
            ntState = PowerDeviceD0;
            break;
        case ACPI_STATE_D1:
            ntState = PowerDeviceD1;
            break;
        case ACPI_STATE_D2:
            ntState = PowerDeviceD2;
            break;
        case ACPI_STATE_D3:
            ntState = PowerDeviceD3;
            break;
        default:
            DPRINT1("Unknown power state (%d) returned by acpi\n",acpistate);
            ntState = PowerDeviceUnspecified;
            break;
    }

    //
    // Initialize the rest
    //
    pdoData->Common.IsFDO = FALSE;
    pdoData->Common.Self =  Pdo;

    pdoData->ParentFdo = FdoData->Common.Self;


    INITIALIZE_PNP_STATE(pdoData->Common);

    pdoData->Common.DevicePowerState = ntState;
    pdoData->Common.SystemPowerState = FdoData->Common.SystemPowerState;

    ExAcquireFastMutex (&FdoData->Mutex);
    InsertTailList(&FdoData->ListOfPDOs, &pdoData->Link);
    FdoData->NumPDOs++;
    ExReleaseFastMutex (&FdoData->Mutex);

    // This should be the last step in initialization.
    Pdo->Flags &= ~DO_DEVICE_INITIALIZING;

}

Referenced by Bus_PlugInDevice().

Bus_InterfaceDereference()

VOID Bus_InterfaceDereference

(

PVOID

Context

)

Bus_InterfaceReference()

VOID Bus_InterfaceReference

(

PVOID

Context

)

Bus_IsSafetyLockEnabled()

BOOLEAN Bus_IsSafetyLockEnabled

(

PVOID

Context

)

Bus_PDO_EvalMethod()

NTSTATUS NTAPI Bus_PDO_EvalMethod	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 85 of file eval.c.

{
  ULONG Signature;
  NTSTATUS Status;
  ACPI_OBJECT_LIST ParamList;
  PACPI_EVAL_INPUT_BUFFER EvalInputBuff = Irp->AssociatedIrp.SystemBuffer;
  ACPI_BUFFER RetBuff = {ACPI_ALLOCATE_BUFFER, NULL};
  PACPI_EVAL_OUTPUT_BUFFER OutputBuf;
  PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
  ACPI_EVAL_INPUT_BUFFER_SIMPLE_INTEGER *SimpleInt;
  ACPI_EVAL_INPUT_BUFFER_SIMPLE_STRING *SimpleStr;
  CHAR MethodName[5];

  if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG))
      return STATUS_INVALID_PARAMETER;

  Signature = *((PULONG)Irp->AssociatedIrp.SystemBuffer);

  switch (Signature)
  {
     case ACPI_EVAL_INPUT_BUFFER_SIGNATURE:
        if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ACPI_EVAL_INPUT_BUFFER))
            return STATUS_INVALID_PARAMETER;

        ParamList.Count = 0;
        break;

     case ACPI_EVAL_INPUT_BUFFER_SIMPLE_INTEGER_SIGNATURE:
        SimpleInt = Irp->AssociatedIrp.SystemBuffer;

        if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ACPI_EVAL_INPUT_BUFFER_SIMPLE_INTEGER))
            return STATUS_INVALID_PARAMETER;

        ParamList.Count = 1;

        ParamList.Pointer = ExAllocatePoolWithTag(NonPagedPool, sizeof(ACPI_OBJECT), 'OpcA');
        if (!ParamList.Pointer) return STATUS_INSUFFICIENT_RESOURCES;

        ParamList.Pointer[0].Type = ACPI_TYPE_INTEGER;
        ParamList.Pointer[0].Integer.Value = SimpleInt->IntegerArgument;
        break;

     case ACPI_EVAL_INPUT_BUFFER_SIMPLE_STRING_SIGNATURE:
        SimpleStr = Irp->AssociatedIrp.SystemBuffer;

        if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ACPI_EVAL_INPUT_BUFFER_SIMPLE_STRING))
            return STATUS_INVALID_PARAMETER;

        ParamList.Count = 1;

        ParamList.Pointer = ExAllocatePoolWithTag(NonPagedPool, sizeof(ACPI_OBJECT), 'OpcA');
        if (!ParamList.Pointer) return STATUS_INSUFFICIENT_RESOURCES;

        ParamList.Pointer[0].String.Pointer = (CHAR*)SimpleStr->String;
        ParamList.Pointer[0].String.Length = SimpleStr->StringLength;
        break;

     default:
        DPRINT1("Unsupported input buffer signature: %d\n", Signature);
        return STATUS_NOT_IMPLEMENTED;
  }

  RtlCopyMemory(MethodName,
                EvalInputBuff->MethodName,
                sizeof(EvalInputBuff->MethodName));
  MethodName[4] = ANSI_NULL;
  Status = AcpiEvaluateObject(DeviceData->AcpiHandle,
                              MethodName,
                              &ParamList,
                              &RetBuff);

  if (ParamList.Count != 0)
      ExFreePoolWithTag(ParamList.Pointer, 'OpcA');

  if (ACPI_SUCCESS(Status))
  {
      ACPI_OBJECT *Obj = RetBuff.Pointer;
      ULONG ExtraParamLength = 0;
      ULONG Count = 1;

      /* If we didn't get anything back then we're done */
      if (!RetBuff.Pointer || RetBuff.Length == 0)
          return STATUS_SUCCESS;

      switch (Obj->Type)
      {
          case ACPI_TYPE_INTEGER:
             ExtraParamLength = sizeof(ACPI_METHOD_ARGUMENT);
             break;

          case ACPI_TYPE_STRING:
             ExtraParamLength = sizeof(ACPI_METHOD_ARGUMENT);
             if (Obj->String.Length + 1 > sizeof(ULONG))
                 ExtraParamLength += Obj->String.Length + 1 - sizeof(ULONG);
             break;

          case ACPI_TYPE_BUFFER:
             ExtraParamLength = sizeof(ACPI_METHOD_ARGUMENT);
             if (Obj->Buffer.Length > sizeof(ULONG))
                 ExtraParamLength += Obj->Buffer.Length + 1 - sizeof(ULONG);
             break;

          case ACPI_TYPE_PACKAGE:
             Status = GetPackageSize(Obj, &Count, &ExtraParamLength);
             if (!NT_SUCCESS(Status))
                 return Status;
             break;

          default:
             ASSERT(FALSE);
             return STATUS_UNSUCCESSFUL;
      }

      DPRINT("ExtraParamLength %lu\n", ExtraParamLength);
      OutputBuf = ExAllocatePoolWithTag(NonPagedPool,
                                        sizeof(ACPI_EVAL_OUTPUT_BUFFER) - sizeof(ACPI_METHOD_ARGUMENT) + ExtraParamLength,
                                        'BpcA');
      if (!OutputBuf)
          return STATUS_INSUFFICIENT_RESOURCES;

      OutputBuf->Signature = ACPI_EVAL_OUTPUT_BUFFER_SIGNATURE;
      OutputBuf->Length = ExtraParamLength;
      OutputBuf->Count = Count;

      switch (Obj->Type)
      {
          case ACPI_TYPE_INTEGER:
             ACPI_METHOD_SET_ARGUMENT_INTEGER(OutputBuf->Argument, Obj->Integer.Value);
             break;

          case ACPI_TYPE_STRING:
             ACPI_METHOD_SET_ARGUMENT_STRING(OutputBuf->Argument, Obj->String.Pointer);
             break;

          case ACPI_TYPE_BUFFER:
             ACPI_METHOD_SET_ARGUMENT_BUFFER(OutputBuf->Argument, Obj->Buffer.Pointer, Obj->Buffer.Length);
             break;

          case ACPI_TYPE_PACKAGE:
             Status = ConvertPackageArguments(OutputBuf->Argument, Obj);
             if (!NT_SUCCESS(Status))
                 return Status;
             break;

          default:
             ASSERT(FALSE);
             return STATUS_UNSUCCESSFUL;
      }

      if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength >= sizeof(ACPI_EVAL_OUTPUT_BUFFER) - sizeof(ACPI_METHOD_ARGUMENT) +
                                                                  ExtraParamLength)
      {
          RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, OutputBuf, sizeof(ACPI_EVAL_OUTPUT_BUFFER) - sizeof(ACPI_METHOD_ARGUMENT) +
                                                                    ExtraParamLength);
          Irp->IoStatus.Information = sizeof(ACPI_EVAL_OUTPUT_BUFFER) - sizeof(ACPI_METHOD_ARGUMENT) + ExtraParamLength;
          ExFreePoolWithTag(OutputBuf, 'BpcA');
          return STATUS_SUCCESS;
      }
      else
      {
          ExFreePoolWithTag(OutputBuf, 'BpcA');
          return STATUS_BUFFER_TOO_SMALL;
      }
  }
  else
  {
      DPRINT1("Query method %4s failed on %p\n", EvalInputBuff->MethodName, DeviceData->AcpiHandle);
      return STATUS_UNSUCCESSFUL;
  }
}

Referenced by ACPIDispatchDeviceControl().

Bus_PDO_PnP()

NTSTATUS Bus_PDO_PnP	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PIO_STACK_LOCATION	IrpStack,
		PPDO_DEVICE_DATA	DeviceData
	)

Definition at line 23 of file buspdo.c.

{
    NTSTATUS                status;
    POWER_STATE             state;
    struct acpi_device      *device = NULL;

    PAGED_CODE ();

    if (DeviceData->AcpiHandle)
        acpi_bus_get_device(DeviceData->AcpiHandle, &device);

    //
    // NB: Because we are a bus enumerator, we have no one to whom we could
    // defer these irps.  Therefore we do not pass them down but merely
    // return them.
    //

    switch (IrpStack->MinorFunction) {

    case IRP_MN_START_DEVICE:
        //
        // Here we do what ever initialization and ``turning on'' that is
        // required to allow others to access this device.
        // Power up the device.
        //
        if (DeviceData->AcpiHandle && acpi_bus_power_manageable(DeviceData->AcpiHandle) &&
            !ACPI_SUCCESS(acpi_bus_set_power(DeviceData->AcpiHandle, ACPI_STATE_D0)))
        {
            DPRINT1("Device %x failed to start!\n", DeviceData->AcpiHandle);
            status = STATUS_UNSUCCESSFUL;
            break;
        }

        DeviceData->InterfaceName.Length = 0;
        status = STATUS_SUCCESS;

        if (!device)
        {
            status = IoRegisterDeviceInterface(DeviceData->Common.Self,
                                               &GUID_DEVICE_SYS_BUTTON,
                                               NULL,
                                               &DeviceData->InterfaceName);
        }
        else if (device->flags.hardware_id &&
                 strstr(device->pnp.hardware_id, ACPI_THERMAL_HID))
        {
            status = IoRegisterDeviceInterface(DeviceData->Common.Self,
                                               &GUID_DEVICE_THERMAL_ZONE,
                                               NULL,
                                               &DeviceData->InterfaceName);
        }
        else if (device->flags.hardware_id &&
                 strstr(device->pnp.hardware_id, ACPI_BUTTON_HID_LID))
        {
            status = IoRegisterDeviceInterface(DeviceData->Common.Self,
                                               &GUID_DEVICE_LID,
                                               NULL,
                                               &DeviceData->InterfaceName);
        }
        else if (device->flags.hardware_id &&
                 strstr(device->pnp.hardware_id, ACPI_PROCESSOR_HID))
        {
            status = IoRegisterDeviceInterface(DeviceData->Common.Self,
                                               &GUID_DEVICE_PROCESSOR,
                                               NULL,
                                               &DeviceData->InterfaceName);
        }

        /* Failure to register an interface is not a fatal failure so don't return a failure status */
        if (NT_SUCCESS(status) && DeviceData->InterfaceName.Length != 0)
            IoSetDeviceInterfaceState(&DeviceData->InterfaceName, TRUE);

        state.DeviceState = PowerDeviceD0;
        PoSetPowerState(DeviceData->Common.Self, DevicePowerState, state);
        DeviceData->Common.DevicePowerState = PowerDeviceD0;
        SET_NEW_PNP_STATE(DeviceData->Common, Started);
        status = STATUS_SUCCESS;
        break;

    case IRP_MN_STOP_DEVICE:

        if (DeviceData->InterfaceName.Length != 0)
            IoSetDeviceInterfaceState(&DeviceData->InterfaceName, FALSE);

        //
        // Here we shut down the device and give up and unmap any resources
        // we acquired for the device.
        //
        if (DeviceData->AcpiHandle && acpi_bus_power_manageable(DeviceData->AcpiHandle) &&
            !ACPI_SUCCESS(acpi_bus_set_power(DeviceData->AcpiHandle, ACPI_STATE_D3)))
        {
            DPRINT1("Device %x failed to stop!\n", DeviceData->AcpiHandle);
            status = STATUS_UNSUCCESSFUL;
            break;
        }

        state.DeviceState = PowerDeviceD3;
        PoSetPowerState(DeviceData->Common.Self, DevicePowerState, state);
        DeviceData->Common.DevicePowerState = PowerDeviceD3;
        SET_NEW_PNP_STATE(DeviceData->Common, Stopped);
        status = STATUS_SUCCESS;
        break;


    case IRP_MN_QUERY_STOP_DEVICE:

        //
        // No reason here why we can't stop the device.
        // If there were a reason we should speak now, because answering success
        // here may result in a stop device irp.
        //

        SET_NEW_PNP_STATE(DeviceData->Common, StopPending);
        status = STATUS_SUCCESS;
        break;

    case IRP_MN_CANCEL_STOP_DEVICE:

        //
        // The stop was canceled.  Whatever state we set, or resources we put
        // on hold in anticipation of the forthcoming STOP device IRP should be
        // put back to normal.  Someone, in the long list of concerned parties,
        // has failed the stop device query.
        //

        //
        // First check to see whether you have received cancel-stop
        // without first receiving a query-stop. This could happen if someone
        // above us fails a query-stop and passes down the subsequent
        // cancel-stop.
        //

        if (StopPending == DeviceData->Common.DevicePnPState)
        {
            //
            // We did receive a query-stop, so restore.
            //
            RESTORE_PREVIOUS_PNP_STATE(DeviceData->Common);
        }
        status = STATUS_SUCCESS;// We must not fail this IRP.
        break;

    case IRP_MN_REMOVE_DEVICE:
        //
        // We handle REMOVE_DEVICE just like STOP_DEVICE. This is because
        // the device is still physically present (or at least we don't know any better)
        // so we have to retain the PDO after stopping and removing power from it.
        //
        if (DeviceData->InterfaceName.Length != 0)
            IoSetDeviceInterfaceState(&DeviceData->InterfaceName, FALSE);

        if (DeviceData->AcpiHandle && acpi_bus_power_manageable(DeviceData->AcpiHandle) &&
            !ACPI_SUCCESS(acpi_bus_set_power(DeviceData->AcpiHandle, ACPI_STATE_D3)))
        {
            DPRINT1("Device %x failed to enter D3!\n", DeviceData->AcpiHandle);
            state.DeviceState = PowerDeviceD3;
            PoSetPowerState(DeviceData->Common.Self, DevicePowerState, state);
            DeviceData->Common.DevicePowerState = PowerDeviceD3;
        }

        SET_NEW_PNP_STATE(DeviceData->Common, Stopped);
        status = STATUS_SUCCESS;
        break;

    case IRP_MN_QUERY_REMOVE_DEVICE:
        SET_NEW_PNP_STATE(DeviceData->Common, RemovalPending);
        status = STATUS_SUCCESS;
        break;

    case IRP_MN_CANCEL_REMOVE_DEVICE:
        if (RemovalPending == DeviceData->Common.DevicePnPState)
        {
            RESTORE_PREVIOUS_PNP_STATE(DeviceData->Common);
        }
        status = STATUS_SUCCESS;
        break;

    case IRP_MN_QUERY_CAPABILITIES:

        //
        // Return the capabilities of a device, such as whether the device
        // can be locked or ejected..etc
        //

        status = Bus_PDO_QueryDeviceCaps(DeviceData, Irp);

        break;

    case IRP_MN_QUERY_ID:

        // Query the IDs of the device
        status = Bus_PDO_QueryDeviceId(DeviceData, Irp);

        break;

    case IRP_MN_QUERY_DEVICE_RELATIONS:

        DPRINT("\tQueryDeviceRelation Type: %s\n",DbgDeviceRelationString(\
                    IrpStack->Parameters.QueryDeviceRelations.Type));

        status = Bus_PDO_QueryDeviceRelations(DeviceData, Irp);

        break;

    case IRP_MN_QUERY_DEVICE_TEXT:

        status = Bus_PDO_QueryDeviceText(DeviceData, Irp);

        break;

    case IRP_MN_QUERY_RESOURCES:

        status = Bus_PDO_QueryResources(DeviceData, Irp);

        break;

    case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:

        status = Bus_PDO_QueryResourceRequirements(DeviceData, Irp);

        break;

    case IRP_MN_QUERY_BUS_INFORMATION:

        status = Bus_PDO_QueryBusInformation(DeviceData, Irp);

        break;

    case IRP_MN_QUERY_INTERFACE:

        status = Bus_PDO_QueryInterface(DeviceData, Irp);

        break;


    case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:

        //
        // OPTIONAL for bus drivers.
        // The PnP Manager sends this IRP to a device
        // stack so filter and function drivers can adjust the
        // resources required by the device, if appropriate.
        //

        //break;

    //case IRP_MN_QUERY_PNP_DEVICE_STATE:

        //
        // OPTIONAL for bus drivers.
        // The PnP Manager sends this IRP after the drivers for
        // a device return success from the IRP_MN_START_DEVICE
        // request. The PnP Manager also sends this IRP when a
        // driver for the device calls IoInvalidateDeviceState.
        //

        // break;

    //case IRP_MN_READ_CONFIG:
    //case IRP_MN_WRITE_CONFIG:

        //
        // Bus drivers for buses with configuration space must handle
        // this request for their child devices. Our devices don't
        // have a config space.
        //

        // break;

    //case IRP_MN_SET_LOCK:

        // break;

    default:

        //
        // For PnP requests to the PDO that we do not understand we should
        // return the IRP WITHOUT setting the status or information fields.
        // These fields may have already been set by a filter (eg acpi).
        status = Irp->IoStatus.Status;

        break;
    }

    Irp->IoStatus.Status = status;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);

    return status;
}

Referenced by Bus_PnP().

Bus_PDO_Power()

NTSTATUS Bus_PDO_Power	(	PPDO_DEVICE_DATA	PdoData,
		PIRP	Irp
	)

Definition at line 116 of file power.c.

{
    NTSTATUS            status;
    PIO_STACK_LOCATION  stack;
    POWER_STATE         powerState;
    POWER_STATE_TYPE    powerType;
    ULONG               error;

    stack = IoGetCurrentIrpStackLocation (Irp);
    powerType = stack->Parameters.Power.Type;
    powerState = stack->Parameters.Power.State;

    switch (stack->MinorFunction) {
    case IRP_MN_SET_POWER:

        DPRINT("\tSetting %s power state to %s\n",
               ((powerType == SystemPowerState) ?  "System" : "Device"),
               ((powerType == SystemPowerState) ? \
               DbgSystemPowerString(powerState.SystemState) : \
               DbgDevicePowerString(powerState.DeviceState)));

        switch (powerType) {
            case DevicePowerState:
                if (!PdoData->AcpiHandle || !acpi_bus_power_manageable(PdoData->AcpiHandle))
                {
                    PoSetPowerState(PdoData->Common.Self, DevicePowerState, powerState);
                    PdoData->Common.DevicePowerState = powerState.DeviceState;
                    status = STATUS_SUCCESS;
                    break;
                }

                switch (powerState.DeviceState)
                {
                    case PowerDeviceD0:
                      error = acpi_bus_set_power(PdoData->AcpiHandle, ACPI_STATE_D0);
                      break;

                    case PowerDeviceD1:
                      error = acpi_bus_set_power(PdoData->AcpiHandle, ACPI_STATE_D1);
                      break;

                    case PowerDeviceD2:
                      error = acpi_bus_set_power(PdoData->AcpiHandle, ACPI_STATE_D2);
                      break;

                    case PowerDeviceD3:
                      error = acpi_bus_set_power(PdoData->AcpiHandle, ACPI_STATE_D3);
                      break;

                    default:
                      error = 0;
                      break;
                }

                if (ACPI_SUCCESS(error))
                {
                    PoSetPowerState(PdoData->Common.Self, DevicePowerState, powerState);
                    PdoData->Common.DevicePowerState = powerState.DeviceState;
                    status = STATUS_SUCCESS;
                }
                else
                    status = STATUS_UNSUCCESSFUL;
                break;

            case SystemPowerState:
                PdoData->Common.SystemPowerState = powerState.SystemState;
                status = STATUS_SUCCESS;
                break;

            default:
                status = STATUS_NOT_SUPPORTED;
                break;
        }
        break;

    case IRP_MN_QUERY_POWER:
        status = STATUS_SUCCESS;
        break;

    case IRP_MN_WAIT_WAKE:
        //
        // We cannot support wait-wake because we are root-enumerated
        // driver, and our parent, the PnP manager, doesn't support wait-wake.
        //
    case IRP_MN_POWER_SEQUENCE:
    default:
        status = STATUS_NOT_SUPPORTED;
        break;
    }

    if (status != STATUS_NOT_SUPPORTED) {

        Irp->IoStatus.Status = status;
    }

    PoStartNextPowerIrp(Irp);
    status = Irp->IoStatus.Status;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);

    return status;
}

Referenced by Bus_Power().

Bus_PDO_QueryBusInformation()

NTSTATUS Bus_PDO_QueryBusInformation	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 1913 of file buspdo.c.

{

    PPNP_BUS_INFORMATION busInfo;

    PAGED_CODE ();

    busInfo = ExAllocatePoolWithTag(PagedPool,
                                    sizeof(PNP_BUS_INFORMATION),
                                    'IpcA');

    if (busInfo == NULL) {
      return STATUS_INSUFFICIENT_RESOURCES;
    }

    busInfo->BusTypeGuid = GUID_ACPI_INTERFACE_STANDARD;

    busInfo->LegacyBusType = InternalPowerBus;

    busInfo->BusNumber = 0; //fixme

    Irp->IoStatus.Information = (ULONG_PTR)busInfo;

    return STATUS_SUCCESS;
}

Referenced by Bus_PDO_PnP().

Bus_PDO_QueryDeviceCaps()

NTSTATUS Bus_PDO_QueryDeviceCaps	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 319 of file buspdo.c.

{

    PIO_STACK_LOCATION      stack;
    PDEVICE_CAPABILITIES    deviceCapabilities;
    struct acpi_device *device = NULL;
    ULONG i;

    PAGED_CODE ();

    if (DeviceData->AcpiHandle)
        acpi_bus_get_device(DeviceData->AcpiHandle, &device);

    stack = IoGetCurrentIrpStackLocation (Irp);

    //
    // Get the packet.
    //
    deviceCapabilities=stack->Parameters.DeviceCapabilities.Capabilities;

    //
    // Set the capabilities.
    //

    if (deviceCapabilities->Version != 1 ||
            deviceCapabilities->Size < sizeof(DEVICE_CAPABILITIES))
    {
       return STATUS_UNSUCCESSFUL;
    }

    deviceCapabilities->D1Latency = 0;
    deviceCapabilities->D2Latency = 0;
    deviceCapabilities->D3Latency = 0;

    deviceCapabilities->DeviceState[PowerSystemWorking] = PowerDeviceD0;
    deviceCapabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD3;
    deviceCapabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD3;
    deviceCapabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;

    for (i = 0; i < ACPI_D_STATE_COUNT && device; i++)
    {
        if (!device->power.states[i].flags.valid)
            continue;

        switch (i)
        {
           case ACPI_STATE_D0:
              deviceCapabilities->DeviceState[PowerSystemWorking] = PowerDeviceD0;
              break;

           case ACPI_STATE_D1:
              deviceCapabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD1;
              deviceCapabilities->D1Latency = device->power.states[i].latency;
              break;

           case ACPI_STATE_D2:
              deviceCapabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD2;
              deviceCapabilities->D2Latency = device->power.states[i].latency;
              break;

           case ACPI_STATE_D3:
              deviceCapabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
              deviceCapabilities->D3Latency = device->power.states[i].latency;
              break;
        }
    }

    // We can wake the system from D1
    deviceCapabilities->DeviceWake = PowerDeviceD1;


    deviceCapabilities->DeviceD1 =
        (deviceCapabilities->DeviceState[PowerSystemSleeping1] == PowerDeviceD1) ? TRUE : FALSE;
    deviceCapabilities->DeviceD2 =
        (deviceCapabilities->DeviceState[PowerSystemSleeping2] == PowerDeviceD2) ? TRUE : FALSE;

    deviceCapabilities->WakeFromD0 = FALSE;
    deviceCapabilities->WakeFromD1 = TRUE; //Yes we can
    deviceCapabilities->WakeFromD2 = FALSE;
    deviceCapabilities->WakeFromD3 = FALSE;

    if (device)
    {
       deviceCapabilities->LockSupported = device->flags.lockable;
       deviceCapabilities->EjectSupported = device->flags.ejectable;
       deviceCapabilities->HardwareDisabled = !device->status.enabled && !device->status.functional;
       deviceCapabilities->Removable = device->flags.removable;
       deviceCapabilities->SurpriseRemovalOK = device->flags.surprise_removal_ok;
       deviceCapabilities->UniqueID = device->flags.unique_id;
       deviceCapabilities->NoDisplayInUI = !device->status.show_in_ui;
       deviceCapabilities->Address = device->pnp.bus_address;
    }

    if (!device ||
        (device->flags.hardware_id &&
         (strstr(device->pnp.hardware_id, ACPI_BUTTON_HID_LID) ||
          strstr(device->pnp.hardware_id, ACPI_THERMAL_HID) ||
          strstr(device->pnp.hardware_id, ACPI_PROCESSOR_HID))))
    {
        /* Allow ACPI to control the device if it is a lid button,
         * a thermal zone, a processor, or a fixed feature button */
        deviceCapabilities->RawDeviceOK = TRUE;
    }

    deviceCapabilities->SilentInstall = FALSE;
    deviceCapabilities->UINumber = (ULONG)-1;

    return STATUS_SUCCESS;

}

Referenced by Bus_PDO_PnP().

Bus_PDO_QueryDeviceId()

NTSTATUS Bus_PDO_QueryDeviceId	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 433 of file buspdo.c.

{
    PIO_STACK_LOCATION      stack;
    PWCHAR                  buffer, src;
    WCHAR                   temp[256];
    ULONG                   length, i;
    NTSTATUS                status = STATUS_SUCCESS;
    struct acpi_device *Device;

    PAGED_CODE ();

    stack = IoGetCurrentIrpStackLocation (Irp);

    switch (stack->Parameters.QueryId.IdType) {

    case BusQueryDeviceID:

        /* This is a REG_SZ value */

        if (DeviceData->AcpiHandle)
        {
            acpi_bus_get_device(DeviceData->AcpiHandle, &Device);

            if (strcmp(Device->pnp.hardware_id, "Processor") == 0)
            {
                length = wcslen(ProcessorIdString);
                wcscpy(temp, ProcessorIdString);
            }
            else
            {
                length = swprintf(temp,
                                  L"ACPI\\%hs",
                                  Device->pnp.hardware_id);
            }
        }
        else
        {
            /* We know it's a fixed feature button because
             * these are direct children of the ACPI root device
             * and therefore have no handle
             */
            length = swprintf(temp,
                              L"ACPI\\FixedButton");
        }

        temp[length++] = UNICODE_NULL;

        NT_ASSERT(length * sizeof(WCHAR) <= sizeof(temp));

        buffer = ExAllocatePoolWithTag(PagedPool, length * sizeof(WCHAR), 'IpcA');

        if (!buffer) {
           status = STATUS_INSUFFICIENT_RESOURCES;
           break;
        }

        RtlCopyMemory (buffer, temp, length * sizeof(WCHAR));
        Irp->IoStatus.Information = (ULONG_PTR) buffer;
        DPRINT("BusQueryDeviceID: %ls\n",buffer);
        break;

    case BusQueryInstanceID:

        /* This is a REG_SZ value */

        /* See comment in BusQueryDeviceID case */
        if(DeviceData->AcpiHandle)
        {
           acpi_bus_get_device(DeviceData->AcpiHandle, &Device);

           if (Device->flags.unique_id)
              length = swprintf(temp,
                                L"%hs",
                                Device->pnp.unique_id);
           else
              /* FIXME: Generate unique id! */
              length = swprintf(temp, L"%ls", L"0");
        }
        else
        {
           /* FIXME: Generate unique id! */
           length = swprintf(temp, L"%ls", L"0");
        }

        temp[length++] = UNICODE_NULL;

        NT_ASSERT(length * sizeof(WCHAR) <= sizeof(temp));

        buffer = ExAllocatePoolWithTag(PagedPool, length * sizeof(WCHAR), 'IpcA');
        if (!buffer) {
           status = STATUS_INSUFFICIENT_RESOURCES;
           break;
        }

        RtlCopyMemory (buffer, temp, length * sizeof (WCHAR));
        DPRINT("BusQueryInstanceID: %ls\n",buffer);
        Irp->IoStatus.Information = (ULONG_PTR) buffer;
        break;

    case BusQueryHardwareIDs:

        /* This is a REG_MULTI_SZ value */
        length = 0;
        status = STATUS_NOT_SUPPORTED;

        /* See comment in BusQueryDeviceID case */
        if (DeviceData->AcpiHandle)
        {
            acpi_bus_get_device(DeviceData->AcpiHandle, &Device);

            if (!Device->flags.hardware_id)
            {
                /* We don't have the ID to satisfy this request */
                break;
            }

            DPRINT("Device name: %s\n", Device->pnp.device_name);
            DPRINT("Hardware ID: %s\n", Device->pnp.hardware_id);

            if (strcmp(Device->pnp.hardware_id, "Processor") == 0)
            {
                length = ProcessorHardwareIds.Length / sizeof(WCHAR);
                src = ProcessorHardwareIds.Buffer;
            }
            else
            {
                length += swprintf(&temp[length],
                                   L"ACPI\\%hs",
                                   Device->pnp.hardware_id);
                temp[length++] = UNICODE_NULL;

                length += swprintf(&temp[length],
                                   L"*%hs",
                                   Device->pnp.hardware_id);
                temp[length++] = UNICODE_NULL;
                temp[length++] = UNICODE_NULL;
                src = temp;
            }
        }
        else
        {
            length += swprintf(&temp[length],
                               L"ACPI\\FixedButton");
            temp[length++] = UNICODE_NULL;

            length += swprintf(&temp[length],
                               L"*FixedButton");
            temp[length++] = UNICODE_NULL;
            temp[length++] = UNICODE_NULL;
            src = temp;
        }

        NT_ASSERT(length * sizeof(WCHAR) <= sizeof(temp));

        buffer = ExAllocatePoolWithTag(PagedPool, length * sizeof(WCHAR), 'IpcA');

        if (!buffer) {
           status = STATUS_INSUFFICIENT_RESOURCES;
           break;
        }

        RtlCopyMemory (buffer, src, length * sizeof(WCHAR));
        Irp->IoStatus.Information = (ULONG_PTR) buffer;
        DPRINT("BusQueryHardwareIDs: %ls\n",buffer);
        status = STATUS_SUCCESS;
        break;

    case BusQueryCompatibleIDs:

        /* This is a REG_MULTI_SZ value */
        length = 0;
        status = STATUS_NOT_SUPPORTED;

        /* See comment in BusQueryDeviceID case */
        if (DeviceData->AcpiHandle)
        {
            acpi_bus_get_device(DeviceData->AcpiHandle, &Device);

            if (!Device->flags.hardware_id)
            {
                /* We don't have the ID to satisfy this request */
                break;
            }

            DPRINT("Device name: %s\n", Device->pnp.device_name);
            DPRINT("Hardware ID: %s\n", Device->pnp.hardware_id);

            if (strcmp(Device->pnp.hardware_id, "Processor") == 0)
            {
                length += swprintf(&temp[length],
                                   L"ACPI\\%hs",
                                   Device->pnp.hardware_id);
                temp[length++] = UNICODE_NULL;

                length += swprintf(&temp[length],
                                   L"*%hs",
                                   Device->pnp.hardware_id);
                temp[length++] = UNICODE_NULL;
                temp[length++] = UNICODE_NULL;
            }
            else if (Device->flags.compatible_ids)
            {
                for (i = 0; i < Device->pnp.cid_list->Count; i++)
                {
                    length += swprintf(&temp[length],
                                   L"ACPI\\%hs",
                                   Device->pnp.cid_list->Ids[i].String);
                    temp[length++] = UNICODE_NULL;

                    length += swprintf(&temp[length],
                                   L"*%hs",
                                   Device->pnp.cid_list->Ids[i].String);
                    temp[length++] = UNICODE_NULL;
                }

                temp[length++] = UNICODE_NULL;
            }
            else
            {
                /* No compatible IDs */
                break;
            }

            NT_ASSERT(length * sizeof(WCHAR) <= sizeof(temp));

            buffer = ExAllocatePoolWithTag(PagedPool, length * sizeof(WCHAR), 'IpcA');
            if (!buffer)
            {
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }

            RtlCopyMemory (buffer, temp, length * sizeof(WCHAR));
            Irp->IoStatus.Information = (ULONG_PTR) buffer;
            DPRINT("BusQueryCompatibleIDs: %ls\n",buffer);
            status = STATUS_SUCCESS;
        }
        break;

    default:
        status = Irp->IoStatus.Status;
    }
    return status;
}

Referenced by Bus_PDO_PnP().

Bus_PDO_QueryDeviceRelations()

NTSTATUS Bus_PDO_QueryDeviceRelations	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 1822 of file buspdo.c.

{

    PIO_STACK_LOCATION   stack;
    PDEVICE_RELATIONS deviceRelations;
    NTSTATUS status;

    PAGED_CODE ();

    stack = IoGetCurrentIrpStackLocation (Irp);

    switch (stack->Parameters.QueryDeviceRelations.Type) {

    case TargetDeviceRelation:

        deviceRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information;
        if (deviceRelations) {
            //
            // Only PDO can handle this request. Somebody above
            // is not playing by rule.
            //
            ASSERTMSG("Someone above is handling TargetDeviceRelation\n", !deviceRelations);
        }

        deviceRelations = ExAllocatePoolWithTag(PagedPool,
                                                sizeof(DEVICE_RELATIONS),
                                                'IpcA');
        if (!deviceRelations) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;
        }

        //
        // There is only one PDO pointer in the structure
        // for this relation type. The PnP Manager removes
        // the reference to the PDO when the driver or application
        // un-registers for notification on the device.
        //

        deviceRelations->Count = 1;
        deviceRelations->Objects[0] = DeviceData->Common.Self;
        ObReferenceObject(DeviceData->Common.Self);

        status = STATUS_SUCCESS;
        Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
        break;

    case BusRelations: // Not handled by PDO
    case EjectionRelations: // optional for PDO
    case RemovalRelations: // // optional for PDO
    default:
        status = Irp->IoStatus.Status;
    }

    return status;
}

Referenced by Bus_PDO_PnP().

Bus_PDO_QueryDeviceText()

NTSTATUS Bus_PDO_QueryDeviceText	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 681 of file buspdo.c.

{
    PWCHAR  Buffer, Temp;
    PIO_STACK_LOCATION   stack;
    NTSTATUS    status = Irp->IoStatus.Status;
    PAGED_CODE ();

    stack = IoGetCurrentIrpStackLocation (Irp);

    switch (stack->Parameters.QueryDeviceText.DeviceTextType) {

    case DeviceTextDescription:

        if (!Irp->IoStatus.Information) {
            if (wcsstr (DeviceData->HardwareIDs, L"PNP000") != 0)
                Temp = L"Programmable interrupt controller";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP010") != 0)
                Temp = L"System timer";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP020") != 0)
                Temp = L"DMA controller";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP03") != 0)
                Temp = L"Keyboard";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP040") != 0)
                Temp = L"Parallel port";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP05") != 0)
                Temp = L"Serial port";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP06") != 0)
                Temp = L"Disk controller";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP07") != 0)
                Temp = L"Disk controller";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP09") != 0)
                Temp = L"Display adapter";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0A0") != 0)
                Temp = L"Bus controller";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0E0") != 0)
                Temp = L"PCMCIA controller";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0F") != 0)
                Temp = L"Mouse device";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP8") != 0)
                Temp = L"Network adapter";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNPA0") != 0)
                Temp = L"SCSI controller";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNPB0") != 0)
                Temp = L"Multimedia device";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNPC00") != 0)
                Temp = L"Modem";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0C") != 0)
                Temp = L"Power Button";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0E") != 0)
                Temp = L"Sleep Button";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0D") != 0)
                Temp = L"Lid Switch";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C09") != 0)
                Temp = L"ACPI Embedded Controller";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0B") != 0)
                Temp = L"ACPI Fan";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0A03") != 0 ||
                     wcsstr(DeviceData->HardwareIDs, L"PNP0A08") != 0)
                Temp = L"PCI Root Bridge";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0A") != 0)
                Temp = L"ACPI Battery";
            else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0F") != 0)
                Temp = L"PCI Interrupt Link";
            else if (wcsstr(DeviceData->HardwareIDs, L"ACPI_PWR") != 0)
                Temp = L"ACPI Power Resource";
            else if (wcsstr(DeviceData->HardwareIDs, L"Processor") != 0)
            {
                if (ProcessorNameString != NULL)
                    Temp = ProcessorNameString;
                else
                    Temp = L"Processor";
            }
            else if (wcsstr(DeviceData->HardwareIDs, L"ThermalZone") != 0)
                Temp = L"ACPI Thermal Zone";
            else if (wcsstr(DeviceData->HardwareIDs, L"ACPI0002") != 0)
                Temp = L"Smart Battery";
            else if (wcsstr(DeviceData->HardwareIDs, L"ACPI0003") != 0)
                Temp = L"AC Adapter";
            /* Simply checking if AcpiHandle is NULL eliminates the need to check
             * for the 4 different names that ACPI knows the fixed feature button as internally
             */
            else if (!DeviceData->AcpiHandle)
                Temp = L"ACPI Fixed Feature Button";
            else
                Temp = L"Other ACPI device";

            Buffer = ExAllocatePoolWithTag(PagedPool, (wcslen(Temp) + 1) * sizeof(WCHAR), 'IpcA');

            if (!Buffer) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }

            RtlCopyMemory (Buffer, Temp, (wcslen(Temp) + 1) * sizeof(WCHAR));

            DPRINT("\tDeviceTextDescription :%ws\n", Buffer);

            Irp->IoStatus.Information = (ULONG_PTR) Buffer;
            status = STATUS_SUCCESS;
        }
        break;

    default:
        break;
    }

    return status;

}

Referenced by Bus_PDO_PnP().

Bus_PDO_QueryInterface()

NTSTATUS Bus_PDO_QueryInterface	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 94 of file interface.c.

{
  PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
  PACPI_INTERFACE_STANDARD AcpiInterface;

  if (IrpSp->Parameters.QueryInterface.Version != 1)
  {
      DPRINT1("Invalid version number: %d\n",
              IrpSp->Parameters.QueryInterface.Version);
      return STATUS_INVALID_PARAMETER;
  }

  if (RtlCompareMemory(IrpSp->Parameters.QueryInterface.InterfaceType,
                        &GUID_ACPI_INTERFACE_STANDARD, sizeof(GUID)) == sizeof(GUID))
  {
      DPRINT("GUID_ACPI_INTERFACE_STANDARD\n");

      if (IrpSp->Parameters.QueryInterface.Size < sizeof(ACPI_INTERFACE_STANDARD))
      {
          DPRINT1("Buffer too small! (%d)\n", IrpSp->Parameters.QueryInterface.Size);
          return STATUS_BUFFER_TOO_SMALL;
      }

     AcpiInterface = (PACPI_INTERFACE_STANDARD)IrpSp->Parameters.QueryInterface.Interface;

     AcpiInterface->InterfaceReference = AcpiInterfaceReference;
     AcpiInterface->InterfaceDereference = AcpiInterfaceDereference;
     AcpiInterface->GpeConnectVector = AcpiInterfaceConnectVector;
     AcpiInterface->GpeDisconnectVector = AcpiInterfaceDisconnectVector;
     AcpiInterface->GpeEnableEvent = AcpiInterfaceEnableEvent;
     AcpiInterface->GpeDisableEvent = AcpiInterfaceDisableEvent;
     AcpiInterface->GpeClearStatus = AcpiInterfaceClearStatus;
     AcpiInterface->RegisterForDeviceNotifications = AcpiInterfaceNotificationsRegister;
     AcpiInterface->UnregisterForDeviceNotifications = AcpiInterfaceNotificationsUnregister;

     return STATUS_SUCCESS;
  }
  else
  {
      DPRINT1("Invalid GUID\n");
      return STATUS_NOT_SUPPORTED;
  }
}

Referenced by Bus_PDO_PnP().

Bus_PDO_QueryResourceRequirements()

NTSTATUS Bus_PDO_QueryResourceRequirements	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 1301 of file buspdo.c.

{
    ULONG NumberOfResources = 0;
    ACPI_STATUS AcpiStatus;
    ACPI_BUFFER Buffer;
    ACPI_RESOURCE* resource;
    ULONG i, RequirementsListSize;
    PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList;
    PIO_RESOURCE_DESCRIPTOR RequirementDescriptor;
    BOOLEAN CurrentRes = FALSE;
    BOOLEAN SeenStartDependent;

    PAGED_CODE ();

    if (!DeviceData->AcpiHandle)
    {
        return Irp->IoStatus.Status;
    }

    /* Handle the PCI root manually */
    if (wcsstr(DeviceData->HardwareIDs, L"PNP0A03") != 0 ||
        wcsstr(DeviceData->HardwareIDs, L"PNP0A08") != 0)
    {
        return Irp->IoStatus.Status;
    }

    /* Get current resources */
    while (TRUE)
    {
        Buffer.Length = 0;
        if (CurrentRes)
        AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
        else
            AcpiStatus = AcpiGetPossibleResources(DeviceData->AcpiHandle, &Buffer);
        if ((!ACPI_SUCCESS(AcpiStatus) && AcpiStatus != AE_BUFFER_OVERFLOW) ||
            Buffer.Length == 0)
        {
            if (!CurrentRes)
                CurrentRes = TRUE;
            else
                return Irp->IoStatus.Status;
        }
        else
            break;
    }

    Buffer.Pointer = ExAllocatePoolWithTag(PagedPool, Buffer.Length, 'BpcA');
    if (!Buffer.Pointer)
      return STATUS_INSUFFICIENT_RESOURCES;

    if (CurrentRes)
        AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
    else
        AcpiStatus = AcpiGetPossibleResources(DeviceData->AcpiHandle, &Buffer);
    if (!ACPI_SUCCESS(AcpiStatus))
    {
      DPRINT1("AcpiGetCurrentResources #2 failed (0x%x)\n", AcpiStatus);
      ASSERT(FALSE);
      return STATUS_UNSUCCESSFUL;
    }

    SeenStartDependent = FALSE;
    resource = Buffer.Pointer;
    /* Count number of resources */
    while (resource->Type != ACPI_RESOURCE_TYPE_END_TAG && resource->Type != ACPI_RESOURCE_TYPE_END_DEPENDENT)
    {
        if (resource->Type == ACPI_RESOURCE_TYPE_START_DEPENDENT)
        {
            if (SeenStartDependent)
            {
                break;
            }
            SeenStartDependent = TRUE;
        }
        switch (resource->Type)
        {
            case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
            {
                ACPI_RESOURCE_EXTENDED_IRQ *irq_data = (ACPI_RESOURCE_EXTENDED_IRQ*) &resource->Data;
                if (irq_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                NumberOfResources += irq_data->InterruptCount;
                break;
            }
            case ACPI_RESOURCE_TYPE_IRQ:
            {
                ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
                NumberOfResources += irq_data->InterruptCount;
                break;
            }
            case ACPI_RESOURCE_TYPE_DMA:
            {
                ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
                NumberOfResources += dma_data->ChannelCount;
                break;
            }
            case ACPI_RESOURCE_TYPE_ADDRESS16:
            case ACPI_RESOURCE_TYPE_ADDRESS32:
            case ACPI_RESOURCE_TYPE_ADDRESS64:
            case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
            {
                ACPI_RESOURCE_ADDRESS *res_addr = (ACPI_RESOURCE_ADDRESS*) &resource->Data;
                if (res_addr->ProducerConsumer == ACPI_PRODUCER)
                    break;
                NumberOfResources++;
                break;
            }
            case ACPI_RESOURCE_TYPE_MEMORY24:
            case ACPI_RESOURCE_TYPE_MEMORY32:
            case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
            case ACPI_RESOURCE_TYPE_FIXED_IO:
            case ACPI_RESOURCE_TYPE_IO:
            {
                NumberOfResources++;
                break;
            }
            default:
            {
                break;
            }
        }
        resource = ACPI_NEXT_RESOURCE(resource);
    }

    RequirementsListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) + sizeof(IO_RESOURCE_DESCRIPTOR) * (NumberOfResources - 1);
    RequirementsList = ExAllocatePoolWithTag(PagedPool, RequirementsListSize, 'RpcA');

    if (!RequirementsList)
    {
        ExFreePoolWithTag(Buffer.Pointer, 'BpcA');
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    RequirementsList->ListSize = RequirementsListSize;
    RequirementsList->InterfaceType = Internal;
    RequirementsList->BusNumber = 0;
    RequirementsList->SlotNumber = 0; /* Not used by WDM drivers */
    RequirementsList->AlternativeLists = 1;
    RequirementsList->List[0].Version = 1;
    RequirementsList->List[0].Revision = 1;
    RequirementsList->List[0].Count = NumberOfResources;
    RequirementDescriptor = RequirementsList->List[0].Descriptors;

    /* Fill resources list structure */
    SeenStartDependent = FALSE;
    resource = Buffer.Pointer;
    while (resource->Type != ACPI_RESOURCE_TYPE_END_TAG && resource->Type != ACPI_RESOURCE_TYPE_END_DEPENDENT)
    {
        if (resource->Type == ACPI_RESOURCE_TYPE_START_DEPENDENT)
        {
            if (SeenStartDependent)
            {
                break;
            }
            SeenStartDependent = TRUE;
        }
        switch (resource->Type)
        {
            case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
            {
                ACPI_RESOURCE_EXTENDED_IRQ *irq_data = &resource->Data.ExtendedIrq;
                if (irq_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                for (i = 0; i < irq_data->InterruptCount; i++)
                {
                    RequirementDescriptor->Option = (i == 0) ? IO_RESOURCE_PREFERRED : IO_RESOURCE_ALTERNATIVE;
                    RequirementDescriptor->Type = CmResourceTypeInterrupt;
                    RequirementDescriptor->ShareDisposition = (irq_data->Shareable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
                    RequirementDescriptor->Flags =(irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
                    RequirementDescriptor->u.Interrupt.MinimumVector =
                    RequirementDescriptor->u.Interrupt.MaximumVector = irq_data->Interrupts[i];

                    RequirementDescriptor++;
                }
                break;
            }
            case ACPI_RESOURCE_TYPE_IRQ:
            {
                ACPI_RESOURCE_IRQ *irq_data = &resource->Data.Irq;
                for (i = 0; i < irq_data->InterruptCount; i++)
                {
                    RequirementDescriptor->Option = (i == 0) ? IO_RESOURCE_PREFERRED : IO_RESOURCE_ALTERNATIVE;
                    RequirementDescriptor->Type = CmResourceTypeInterrupt;
                    RequirementDescriptor->ShareDisposition = (irq_data->Shareable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
                    RequirementDescriptor->Flags =(irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
                    RequirementDescriptor->u.Interrupt.MinimumVector =
                    RequirementDescriptor->u.Interrupt.MaximumVector = irq_data->Interrupts[i];

                    RequirementDescriptor++;
                }
                break;
            }
            case ACPI_RESOURCE_TYPE_DMA:
            {
                ACPI_RESOURCE_DMA *dma_data = &resource->Data.Dma;
                for (i = 0; i < dma_data->ChannelCount; i++)
                {
                    RequirementDescriptor->Type = CmResourceTypeDma;
                    RequirementDescriptor->Flags = 0;
                    switch (dma_data->Type)
                    {
                        case ACPI_TYPE_A: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_A; break;
                        case ACPI_TYPE_B: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_B; break;
                        case ACPI_TYPE_F: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_F; break;
                    }
                    if (dma_data->BusMaster == ACPI_BUS_MASTER)
                        RequirementDescriptor->Flags |= CM_RESOURCE_DMA_BUS_MASTER;
                    switch (dma_data->Transfer)
                    {
                        case ACPI_TRANSFER_8: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_8; break;
                        case ACPI_TRANSFER_16: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_16; break;
                        case ACPI_TRANSFER_8_16: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_8_AND_16; break;
                    }

                    RequirementDescriptor->Option = (i == 0) ? IO_RESOURCE_PREFERRED : IO_RESOURCE_ALTERNATIVE;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
                    RequirementDescriptor->u.Dma.MinimumChannel =
                    RequirementDescriptor->u.Dma.MaximumChannel = dma_data->Channels[i];
                    RequirementDescriptor++;
                }
                break;
            }
            case ACPI_RESOURCE_TYPE_IO:
            {
                ACPI_RESOURCE_IO *io_data = &resource->Data.Io;
                RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
                if (io_data->IoDecode == ACPI_DECODE_16)
                    RequirementDescriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE;
                else
                    RequirementDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
                RequirementDescriptor->u.Port.Length = io_data->AddressLength;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                RequirementDescriptor->Type = CmResourceTypePort;
                RequirementDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
                RequirementDescriptor->u.Port.Alignment = io_data->Alignment;
                RequirementDescriptor->u.Port.MinimumAddress.QuadPart = io_data->Minimum;
                RequirementDescriptor->u.Port.MaximumAddress.QuadPart = io_data->Maximum + io_data->AddressLength - 1;

                RequirementDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_FIXED_IO:
            {
                ACPI_RESOURCE_FIXED_IO *io_data = &resource->Data.FixedIo;
                RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
                RequirementDescriptor->u.Port.Length = io_data->AddressLength;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                RequirementDescriptor->Type = CmResourceTypePort;
                RequirementDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
                RequirementDescriptor->u.Port.Alignment = 1;
                RequirementDescriptor->u.Port.MinimumAddress.QuadPart = io_data->Address;
                RequirementDescriptor->u.Port.MaximumAddress.QuadPart = io_data->Address + io_data->AddressLength - 1;

                RequirementDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_ADDRESS16:
            {
                ACPI_RESOURCE_ADDRESS16 *addr16_data = &resource->Data.Address16;
                if (addr16_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                if (addr16_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
                {
                    RequirementDescriptor->Type = CmResourceTypeBusNumber;
                    RequirementDescriptor->ShareDisposition = CmResourceShareShared;
                    RequirementDescriptor->Flags = 0;
                    RequirementDescriptor->u.BusNumber.MinBusNumber = addr16_data->Address.Minimum;
                    RequirementDescriptor->u.BusNumber.MaxBusNumber = addr16_data->Address.Maximum + addr16_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.BusNumber.Length = addr16_data->Address.AddressLength;
                }
                else if (addr16_data->ResourceType == ACPI_IO_RANGE)
                {
                    RequirementDescriptor->Type = CmResourceTypePort;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
                    if (addr16_data->Decode == ACPI_POS_DECODE)
                        RequirementDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
                    RequirementDescriptor->u.Port.MinimumAddress.QuadPart = addr16_data->Address.Minimum;
                    RequirementDescriptor->u.Port.MaximumAddress.QuadPart = addr16_data->Address.Maximum + addr16_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.Port.Length = addr16_data->Address.AddressLength;
                }
                else
                {
                    RequirementDescriptor->Type = CmResourceTypeMemory;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    RequirementDescriptor->Flags = 0;
                    if (addr16_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
                        RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                    else
                        RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                    switch (addr16_data->Info.Mem.Caching)
                    {
                        case ACPI_CACHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
                        case ACPI_WRITE_COMBINING_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
                        case ACPI_PREFETCHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
                    }
                    RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = addr16_data->Address.Minimum;
                    RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = addr16_data->Address.Maximum + addr16_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.Memory.Length = addr16_data->Address.AddressLength;
                }
                RequirementDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_ADDRESS32:
            {
                ACPI_RESOURCE_ADDRESS32 *addr32_data = &resource->Data.Address32;
                if (addr32_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                if (addr32_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
                {
                    RequirementDescriptor->Type = CmResourceTypeBusNumber;
                    RequirementDescriptor->ShareDisposition = CmResourceShareShared;
                    RequirementDescriptor->Flags = 0;
                    RequirementDescriptor->u.BusNumber.MinBusNumber = addr32_data->Address.Minimum;
                    RequirementDescriptor->u.BusNumber.MaxBusNumber = addr32_data->Address.Maximum + addr32_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.BusNumber.Length = addr32_data->Address.AddressLength;
                }
                else if (addr32_data->ResourceType == ACPI_IO_RANGE)
                {
                    RequirementDescriptor->Type = CmResourceTypePort;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
                    if (addr32_data->Decode == ACPI_POS_DECODE)
                        RequirementDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
                    RequirementDescriptor->u.Port.MinimumAddress.QuadPart = addr32_data->Address.Minimum;
                    RequirementDescriptor->u.Port.MaximumAddress.QuadPart = addr32_data->Address.Maximum + addr32_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.Port.Length = addr32_data->Address.AddressLength;
                }
                else
                {
                    RequirementDescriptor->Type = CmResourceTypeMemory;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    RequirementDescriptor->Flags = 0;
                    if (addr32_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
                        RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                    else
                        RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                    switch (addr32_data->Info.Mem.Caching)
                    {
                        case ACPI_CACHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
                        case ACPI_WRITE_COMBINING_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
                        case ACPI_PREFETCHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
                    }
                    RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = addr32_data->Address.Minimum;
                    RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = addr32_data->Address.Maximum + addr32_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.Memory.Length = addr32_data->Address.AddressLength;
                }
                RequirementDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_ADDRESS64:
            {
                ACPI_RESOURCE_ADDRESS64 *addr64_data = &resource->Data.Address64;
                if (addr64_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                if (addr64_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
                {
                    DPRINT1("64-bit bus address is not supported!\n");
                    RequirementDescriptor->Type = CmResourceTypeBusNumber;
                    RequirementDescriptor->ShareDisposition = CmResourceShareShared;
                    RequirementDescriptor->Flags = 0;
                    RequirementDescriptor->u.BusNumber.MinBusNumber = (ULONG)addr64_data->Address.Minimum;
                    RequirementDescriptor->u.BusNumber.MaxBusNumber = (ULONG)addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.BusNumber.Length = addr64_data->Address.AddressLength;
                }
                else if (addr64_data->ResourceType == ACPI_IO_RANGE)
                {
                    RequirementDescriptor->Type = CmResourceTypePort;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
                    if (addr64_data->Decode == ACPI_POS_DECODE)
                        RequirementDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
                    RequirementDescriptor->u.Port.MinimumAddress.QuadPart = addr64_data->Address.Minimum;
                    RequirementDescriptor->u.Port.MaximumAddress.QuadPart = addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.Port.Length = addr64_data->Address.AddressLength;
                }
                else
                {
                    RequirementDescriptor->Type = CmResourceTypeMemory;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    RequirementDescriptor->Flags = 0;
                    if (addr64_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
                        RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                    else
                        RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                    switch (addr64_data->Info.Mem.Caching)
                    {
                        case ACPI_CACHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
                        case ACPI_WRITE_COMBINING_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
                        case ACPI_PREFETCHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
                    }
                    RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = addr64_data->Address.Minimum;
                    RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.Memory.Length = addr64_data->Address.AddressLength;
                }
                RequirementDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
            {
                ACPI_RESOURCE_EXTENDED_ADDRESS64 *addr64_data = &resource->Data.ExtAddress64;
                if (addr64_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                if (addr64_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
                {
                    DPRINT1("64-bit bus address is not supported!\n");
                    RequirementDescriptor->Type = CmResourceTypeBusNumber;
                    RequirementDescriptor->ShareDisposition = CmResourceShareShared;
                    RequirementDescriptor->Flags = 0;
                    RequirementDescriptor->u.BusNumber.MinBusNumber = (ULONG)addr64_data->Address.Minimum;
                    RequirementDescriptor->u.BusNumber.MaxBusNumber = (ULONG)addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.BusNumber.Length = addr64_data->Address.AddressLength;
                }
                else if (addr64_data->ResourceType == ACPI_IO_RANGE)
                {
                    RequirementDescriptor->Type = CmResourceTypePort;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
                    if (addr64_data->Decode == ACPI_POS_DECODE)
                        RequirementDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
                    RequirementDescriptor->u.Port.MinimumAddress.QuadPart = addr64_data->Address.Minimum;
                    RequirementDescriptor->u.Port.MaximumAddress.QuadPart = addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.Port.Length = addr64_data->Address.AddressLength;
                }
                else
                {
                    RequirementDescriptor->Type = CmResourceTypeMemory;
                    RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    RequirementDescriptor->Flags = 0;
                    if (addr64_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
                        RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                    else
                        RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                    switch (addr64_data->Info.Mem.Caching)
                    {
                        case ACPI_CACHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
                        case ACPI_WRITE_COMBINING_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
                        case ACPI_PREFETCHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
                    }
                    RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = addr64_data->Address.Minimum;
                    RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
                    RequirementDescriptor->u.Memory.Length = addr64_data->Address.AddressLength;
                }
                RequirementDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_MEMORY24:
            {
                ACPI_RESOURCE_MEMORY24 *mem24_data = &resource->Data.Memory24;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                RequirementDescriptor->Type = CmResourceTypeMemory;
                RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                RequirementDescriptor->Flags = CM_RESOURCE_MEMORY_24;
                if (mem24_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
                    RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                else
                    RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = mem24_data->Minimum;
                RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = mem24_data->Maximum + mem24_data->AddressLength - 1;
                RequirementDescriptor->u.Memory.Length = mem24_data->AddressLength;

                RequirementDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_MEMORY32:
            {
                ACPI_RESOURCE_MEMORY32 *mem32_data = &resource->Data.Memory32;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                RequirementDescriptor->Type = CmResourceTypeMemory;
                RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                RequirementDescriptor->Flags = 0;
                if (mem32_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
                    RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                else
                    RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = mem32_data->Minimum;
                RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = mem32_data->Maximum + mem32_data->AddressLength - 1;
                RequirementDescriptor->u.Memory.Length = mem32_data->AddressLength;

                RequirementDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
            {
                ACPI_RESOURCE_FIXED_MEMORY32 *fixedmem32_data = &resource->Data.FixedMemory32;
                RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
                RequirementDescriptor->Type = CmResourceTypeMemory;
                RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                RequirementDescriptor->Flags = 0;
                if (fixedmem32_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
                    RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                else
                    RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = fixedmem32_data->Address;
                RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = fixedmem32_data->Address + fixedmem32_data->AddressLength - 1;
                RequirementDescriptor->u.Memory.Length = fixedmem32_data->AddressLength;

                RequirementDescriptor++;
                break;
            }
            default:
            {
                break;
            }
        }
        resource = ACPI_NEXT_RESOURCE(resource);
    }
    ExFreePoolWithTag(Buffer.Pointer, 'BpcA');

    Irp->IoStatus.Information = (ULONG_PTR)RequirementsList;

    return STATUS_SUCCESS;
}

Referenced by Bus_PDO_PnP(), and START_TEST().

Bus_PDO_QueryResources()

NTSTATUS Bus_PDO_QueryResources	(	PPDO_DEVICE_DATA	DeviceData,
		PIRP	Irp
	)

Definition at line 794 of file buspdo.c.

{
    ULONG NumberOfResources = 0;
    PCM_RESOURCE_LIST ResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor;
    ACPI_STATUS AcpiStatus;
    ACPI_BUFFER Buffer;
    ACPI_RESOURCE* resource;
    ULONG ResourceListSize;
    ULONG i;
    ULONGLONG BusNumber;
    struct acpi_device *device;

    if (!DeviceData->AcpiHandle)
    {
        return Irp->IoStatus.Status;
    }

    /* A bus number resource is not included in the list of current resources
     * for the root PCI bus so we manually query one here and if we find it
     * we create a resource list and add a bus number descriptor to it */
    if (wcsstr(DeviceData->HardwareIDs, L"PNP0A03") != 0 ||
        wcsstr(DeviceData->HardwareIDs, L"PNP0A08") != 0)
    {
        acpi_bus_get_device(DeviceData->AcpiHandle, &device);

        AcpiStatus = acpi_evaluate_integer(DeviceData->AcpiHandle, "_BBN", NULL, &BusNumber);
        if (AcpiStatus != AE_OK)
        {
#if 0
            if (device->flags.unique_id)
            {
                /* FIXME: Try the unique ID */
            }
            else
#endif
            {
                BusNumber = 0;
                DPRINT1("Failed to find a bus number\n");
            }
        }
        else
        {
            DPRINT("Using _BBN for bus number\n");
        }

        DPRINT("Found PCI root hub: %d\n", BusNumber);

        ResourceListSize = sizeof(CM_RESOURCE_LIST);
        ResourceList = ExAllocatePoolWithTag(PagedPool, ResourceListSize, 'RpcA');
        if (!ResourceList)
            return STATUS_INSUFFICIENT_RESOURCES;

        ResourceList->Count = 1;
        ResourceList->List[0].InterfaceType = Internal;
        ResourceList->List[0].BusNumber = 0;
        ResourceList->List[0].PartialResourceList.Version = 1;
        ResourceList->List[0].PartialResourceList.Revision = 1;
        ResourceList->List[0].PartialResourceList.Count = 1;
        ResourceDescriptor = ResourceList->List[0].PartialResourceList.PartialDescriptors;

        ResourceDescriptor->Type = CmResourceTypeBusNumber;
        ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
        ResourceDescriptor->u.BusNumber.Start = BusNumber;
        ResourceDescriptor->u.BusNumber.Length = 1;

        Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
        return STATUS_SUCCESS;
    }

    /* Get current resources */
    Buffer.Length = 0;
    AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
    if ((!ACPI_SUCCESS(AcpiStatus) && AcpiStatus != AE_BUFFER_OVERFLOW) ||
        Buffer.Length == 0)
    {
      return Irp->IoStatus.Status;
    }

    Buffer.Pointer = ExAllocatePoolWithTag(PagedPool, Buffer.Length, 'BpcA');
    if (!Buffer.Pointer)
      return STATUS_INSUFFICIENT_RESOURCES;

    AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
    if (!ACPI_SUCCESS(AcpiStatus))
    {
      DPRINT1("AcpiGetCurrentResources #2 failed (0x%x)\n", AcpiStatus);
      ASSERT(FALSE);
      return STATUS_UNSUCCESSFUL;
    }

    resource= Buffer.Pointer;
    /* Count number of resources */
    while (resource->Type != ACPI_RESOURCE_TYPE_END_TAG)
    {
        switch (resource->Type)
        {
            case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
            {
                ACPI_RESOURCE_EXTENDED_IRQ *irq_data = (ACPI_RESOURCE_EXTENDED_IRQ*) &resource->Data;
                if (irq_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                NumberOfResources += irq_data->InterruptCount;
                break;
            }
            case ACPI_RESOURCE_TYPE_IRQ:
            {
                ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
                NumberOfResources += irq_data->InterruptCount;
                break;
            }
            case ACPI_RESOURCE_TYPE_DMA:
            {
                ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
                NumberOfResources += dma_data->ChannelCount;
                break;
            }
            case ACPI_RESOURCE_TYPE_ADDRESS16:
            case ACPI_RESOURCE_TYPE_ADDRESS32:
            case ACPI_RESOURCE_TYPE_ADDRESS64:
            case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
            {
                ACPI_RESOURCE_ADDRESS *addr_res = (ACPI_RESOURCE_ADDRESS*) &resource->Data;
                if (addr_res->ProducerConsumer == ACPI_PRODUCER)
                    break;
                NumberOfResources++;
                break;
            }
            case ACPI_RESOURCE_TYPE_MEMORY24:
            case ACPI_RESOURCE_TYPE_MEMORY32:
            case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
            case ACPI_RESOURCE_TYPE_FIXED_IO:
            case ACPI_RESOURCE_TYPE_IO:
            {
                NumberOfResources++;
                break;
            }
            default:
            {
                DPRINT1("Unknown resource type: %d\n", resource->Type);
                break;
            }
        }
        resource = ACPI_NEXT_RESOURCE(resource);
    }

    /* Allocate memory */
    ResourceListSize = sizeof(CM_RESOURCE_LIST) + sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * (NumberOfResources - 1);
    ResourceList = ExAllocatePoolWithTag(PagedPool, ResourceListSize, 'RpcA');

    if (!ResourceList)
    {
        ExFreePoolWithTag(Buffer.Pointer, 'BpcA');
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    ResourceList->Count = 1;
    ResourceList->List[0].InterfaceType = Internal; /* FIXME */
    ResourceList->List[0].BusNumber = 0; /* We're the only ACPI bus device in the system */
    ResourceList->List[0].PartialResourceList.Version = 1;
    ResourceList->List[0].PartialResourceList.Revision = 1;
    ResourceList->List[0].PartialResourceList.Count = NumberOfResources;
    ResourceDescriptor = ResourceList->List[0].PartialResourceList.PartialDescriptors;

    /* Fill resources list structure */
        resource = Buffer.Pointer;
    while (resource->Type != ACPI_RESOURCE_TYPE_END_TAG)
    {
        switch (resource->Type)
        {
            case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
            {
                ACPI_RESOURCE_EXTENDED_IRQ *irq_data = (ACPI_RESOURCE_EXTENDED_IRQ*) &resource->Data;
                if (irq_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                for (i = 0; i < irq_data->InterruptCount; i++)
                {
                    ResourceDescriptor->Type = CmResourceTypeInterrupt;

                    ResourceDescriptor->ShareDisposition =
                    (irq_data->Shareable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
                    ResourceDescriptor->Flags =
                    (irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
                    ResourceDescriptor->u.Interrupt.Level =
                    ResourceDescriptor->u.Interrupt.Vector = irq_data->Interrupts[i];
                    ResourceDescriptor->u.Interrupt.Affinity = (KAFFINITY)(-1);

                    ResourceDescriptor++;
                }
                break;
            }
            case ACPI_RESOURCE_TYPE_IRQ:
            {
                ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
                for (i = 0; i < irq_data->InterruptCount; i++)
                {
                    ResourceDescriptor->Type = CmResourceTypeInterrupt;

                    ResourceDescriptor->ShareDisposition =
                    (irq_data->Shareable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
                    ResourceDescriptor->Flags =
                    (irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
                    ResourceDescriptor->u.Interrupt.Level =
                    ResourceDescriptor->u.Interrupt.Vector = irq_data->Interrupts[i];
                    ResourceDescriptor->u.Interrupt.Affinity = (KAFFINITY)(-1);

                    ResourceDescriptor++;
                }
                break;
            }
            case ACPI_RESOURCE_TYPE_DMA:
            {
                ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
                for (i = 0; i < dma_data->ChannelCount; i++)
                {
                    ResourceDescriptor->Type = CmResourceTypeDma;
                    ResourceDescriptor->Flags = 0;
                    switch (dma_data->Type)
                    {
                        case ACPI_TYPE_A: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_A; break;
                        case ACPI_TYPE_B: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_B; break;
                        case ACPI_TYPE_F: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_F; break;
                    }
                    if (dma_data->BusMaster == ACPI_BUS_MASTER)
                        ResourceDescriptor->Flags |= CM_RESOURCE_DMA_BUS_MASTER;
                    switch (dma_data->Transfer)
                    {
                        case ACPI_TRANSFER_8: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_8; break;
                        case ACPI_TRANSFER_16: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_16; break;
                        case ACPI_TRANSFER_8_16: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_8_AND_16; break;
                    }
                    ResourceDescriptor->u.Dma.Channel = dma_data->Channels[i];

                    ResourceDescriptor++;
                }
                break;
            }
            case ACPI_RESOURCE_TYPE_IO:
            {
                ACPI_RESOURCE_IO *io_data = (ACPI_RESOURCE_IO*) &resource->Data;
                ResourceDescriptor->Type = CmResourceTypePort;
                ResourceDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
                ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
                if (io_data->IoDecode == ACPI_DECODE_16)
                    ResourceDescriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE;
                else
                    ResourceDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
                ResourceDescriptor->u.Port.Start.QuadPart = io_data->Minimum;
                ResourceDescriptor->u.Port.Length = io_data->AddressLength;

                ResourceDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_FIXED_IO:
            {
                ACPI_RESOURCE_FIXED_IO *io_data = (ACPI_RESOURCE_FIXED_IO*) &resource->Data;
                ResourceDescriptor->Type = CmResourceTypePort;
                ResourceDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
                ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
                ResourceDescriptor->u.Port.Start.QuadPart = io_data->Address;
                ResourceDescriptor->u.Port.Length = io_data->AddressLength;

                ResourceDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_ADDRESS16:
            {
                ACPI_RESOURCE_ADDRESS16 *addr16_data = (ACPI_RESOURCE_ADDRESS16*) &resource->Data;
                if (addr16_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                if (addr16_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
                {
                    ResourceDescriptor->Type = CmResourceTypeBusNumber;
                    ResourceDescriptor->ShareDisposition = CmResourceShareShared;
                    ResourceDescriptor->Flags = 0;
                    ResourceDescriptor->u.BusNumber.Start = addr16_data->Address.Minimum;
                    ResourceDescriptor->u.BusNumber.Length = addr16_data->Address.AddressLength;
                }
                else if (addr16_data->ResourceType == ACPI_IO_RANGE)
                {
                    ResourceDescriptor->Type = CmResourceTypePort;
                    ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
                    if (addr16_data->Decode == ACPI_POS_DECODE)
                        ResourceDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
                    ResourceDescriptor->u.Port.Start.QuadPart = addr16_data->Address.Minimum;
                    ResourceDescriptor->u.Port.Length = addr16_data->Address.AddressLength;
                }
                else
                {
                    ResourceDescriptor->Type = CmResourceTypeMemory;
                    ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    ResourceDescriptor->Flags = 0;
                    if (addr16_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
                        ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                    else
                        ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                    switch (addr16_data->Info.Mem.Caching)
                    {
                        case ACPI_CACHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
                        case ACPI_WRITE_COMBINING_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
                        case ACPI_PREFETCHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
                    }
                    ResourceDescriptor->u.Memory.Start.QuadPart = addr16_data->Address.Minimum;
                    ResourceDescriptor->u.Memory.Length = addr16_data->Address.AddressLength;
                }
                ResourceDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_ADDRESS32:
            {
                ACPI_RESOURCE_ADDRESS32 *addr32_data = (ACPI_RESOURCE_ADDRESS32*) &resource->Data;
                if (addr32_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                if (addr32_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
                {
                    ResourceDescriptor->Type = CmResourceTypeBusNumber;
                    ResourceDescriptor->ShareDisposition = CmResourceShareShared;
                    ResourceDescriptor->Flags = 0;
                    ResourceDescriptor->u.BusNumber.Start = addr32_data->Address.Minimum;
                    ResourceDescriptor->u.BusNumber.Length = addr32_data->Address.AddressLength;
                }
                else if (addr32_data->ResourceType == ACPI_IO_RANGE)
                {
                    ResourceDescriptor->Type = CmResourceTypePort;
                    ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
                    if (addr32_data->Decode == ACPI_POS_DECODE)
                        ResourceDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
                    ResourceDescriptor->u.Port.Start.QuadPart = addr32_data->Address.Minimum;
                    ResourceDescriptor->u.Port.Length = addr32_data->Address.AddressLength;
                }
                else
                {
                    ResourceDescriptor->Type = CmResourceTypeMemory;
                    ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    ResourceDescriptor->Flags = 0;
                    if (addr32_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
                        ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                    else
                        ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                    switch (addr32_data->Info.Mem.Caching)
                    {
                        case ACPI_CACHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
                        case ACPI_WRITE_COMBINING_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
                        case ACPI_PREFETCHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
                    }
                    ResourceDescriptor->u.Memory.Start.QuadPart = addr32_data->Address.Minimum;
                    ResourceDescriptor->u.Memory.Length = addr32_data->Address.AddressLength;
                }
                ResourceDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_ADDRESS64:
            {
                ACPI_RESOURCE_ADDRESS64 *addr64_data = (ACPI_RESOURCE_ADDRESS64*) &resource->Data;
                if (addr64_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                if (addr64_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
                {
                    DPRINT1("64-bit bus address is not supported!\n");
                    ResourceDescriptor->Type = CmResourceTypeBusNumber;
                    ResourceDescriptor->ShareDisposition = CmResourceShareShared;
                    ResourceDescriptor->Flags = 0;
                    ResourceDescriptor->u.BusNumber.Start = (ULONG)addr64_data->Address.Minimum;
                    ResourceDescriptor->u.BusNumber.Length = addr64_data->Address.AddressLength;
                }
                else if (addr64_data->ResourceType == ACPI_IO_RANGE)
                {
                    ResourceDescriptor->Type = CmResourceTypePort;
                    ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
                    if (addr64_data->Decode == ACPI_POS_DECODE)
                        ResourceDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
                    ResourceDescriptor->u.Port.Start.QuadPart = addr64_data->Address.Minimum;
                    ResourceDescriptor->u.Port.Length = addr64_data->Address.AddressLength;
                }
                else
                {
                    ResourceDescriptor->Type = CmResourceTypeMemory;
                    ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    ResourceDescriptor->Flags = 0;
                    if (addr64_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
                        ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                    else
                        ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                    switch (addr64_data->Info.Mem.Caching)
                    {
                        case ACPI_CACHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
                        case ACPI_WRITE_COMBINING_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
                        case ACPI_PREFETCHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
                    }
                    ResourceDescriptor->u.Memory.Start.QuadPart = addr64_data->Address.Minimum;
                    ResourceDescriptor->u.Memory.Length = addr64_data->Address.AddressLength;
                }
                ResourceDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
            {
                ACPI_RESOURCE_EXTENDED_ADDRESS64 *addr64_data = (ACPI_RESOURCE_EXTENDED_ADDRESS64*) &resource->Data;
                if (addr64_data->ProducerConsumer == ACPI_PRODUCER)
                    break;
                if (addr64_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
                {
                    DPRINT1("64-bit bus address is not supported!\n");
                    ResourceDescriptor->Type = CmResourceTypeBusNumber;
                    ResourceDescriptor->ShareDisposition = CmResourceShareShared;
                    ResourceDescriptor->Flags = 0;
                    ResourceDescriptor->u.BusNumber.Start = (ULONG)addr64_data->Address.Minimum;
                    ResourceDescriptor->u.BusNumber.Length = addr64_data->Address.AddressLength;
                }
                else if (addr64_data->ResourceType == ACPI_IO_RANGE)
                {
                    ResourceDescriptor->Type = CmResourceTypePort;
                    ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
                    if (addr64_data->Decode == ACPI_POS_DECODE)
                        ResourceDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
                    ResourceDescriptor->u.Port.Start.QuadPart = addr64_data->Address.Minimum;
                    ResourceDescriptor->u.Port.Length = addr64_data->Address.AddressLength;
                }
                else
                {
                    ResourceDescriptor->Type = CmResourceTypeMemory;
                    ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                    ResourceDescriptor->Flags = 0;
                    if (addr64_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
                        ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                    else
                        ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                    switch (addr64_data->Info.Mem.Caching)
                    {
                        case ACPI_CACHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
                        case ACPI_WRITE_COMBINING_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
                        case ACPI_PREFETCHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
                    }
                    ResourceDescriptor->u.Memory.Start.QuadPart = addr64_data->Address.Minimum;
                    ResourceDescriptor->u.Memory.Length = addr64_data->Address.AddressLength;
                }
                ResourceDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_MEMORY24:
            {
                ACPI_RESOURCE_MEMORY24 *mem24_data = (ACPI_RESOURCE_MEMORY24*) &resource->Data;
                ResourceDescriptor->Type = CmResourceTypeMemory;
                ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                ResourceDescriptor->Flags = CM_RESOURCE_MEMORY_24;
                if (mem24_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
                    ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
                else
                    ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
                ResourceDescriptor->u.Memory.Start.QuadPart = mem24_data->Minimum;
                ResourceDescriptor->u.Memory.Length = mem24_data->AddressLength;

                ResourceDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_MEMORY32:
            {
                ACPI_RESOURCE_MEMORY32 *mem32_data = (