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 (_In_ PPDO_DEVICE_DATA DeviceData, _Inout_ PIRP Irp)
NTSTATUS NTAPI	Bus_CreateClose (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	Bus_DriverUnload (PDRIVER_OBJECT DriverObject)
PCHAR	PnPMinorFunctionString (UCHAR MinorFunction)
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 77 of file acpisys.h.

INITIALIZE_PNP_STATE

#define INITIALIZE_PNP_STATE

(

_Data_

)

Value:

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

Definition at line 80 of file acpisys.h.

RESTORE_PREVIOUS_PNP_STATE

#define RESTORE_PREVIOUS_PNP_STATE

(

_Data_

)

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

Definition at line 88 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 84 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_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 1973 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;
    ACPI_HANDLE handle = 0;
    ACPI_STATUS status = 0;
 
    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;
 
    /* Identify the dock device */
    if (pdoData->AcpiHandle)
    {
        status = AcpiGetHandle(pdoData->AcpiHandle, "_DCK", &handle);
        if (ACPI_SUCCESS(status))
        {
            DPRINT("Found _DCK method!");
            pdoData->DockDevice = TRUE;
        }
    }
 
    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	(	_In_ PPDO_DEVICE_DATA	DeviceData,
		_Inout_ PIRP	Irp
	)

Definition at line 765 of file eval.c.

{
    PIO_STACK_LOCATION IoStack;
    PACPI_EVAL_INPUT_BUFFER EvalInputBuffer;
    ACPI_OBJECT_LIST ParamList;
    ACPI_STATUS AcpiStatus;
    NTSTATUS Status;
    ACPI_BUFFER ReturnBuffer = { ACPI_ALLOCATE_BUFFER, NULL };
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    EvalInputBuffer = Irp->AssociatedIrp.SystemBuffer;
 
    Status = EvalCreateParametersList(Irp, IoStack, EvalInputBuffer, &ParamList);
    if (!NT_SUCCESS(Status))
        return Status;
 
    AcpiStatus = EvalEvaluateObject(DeviceData, EvalInputBuffer, &ParamList, &ReturnBuffer);
 
    if (ParamList.Count != 0)
        EvalFreeParametersList(&ParamList);
 
    if (!ACPI_SUCCESS(AcpiStatus))
    {
        DPRINT("Query method '%.4s' failed on %p with status 0x%04x\n",
               EvalInputBuffer->MethodName,
               DeviceData->AcpiHandle,
               AcpiStatus);
 
        return EvalAcpiStatusToNtStatus(AcpiStatus);
    }
 
    Status = EvalCreateOutputArguments(Irp, IoStack, &ReturnBuffer);
 
    if (ReturnBuffer.Pointer)
        AcpiOsFree(ReturnBuffer.Pointer);
 
    return Status;
}

Referenced by ACPIDispatchDeviceControl(), and DrvCallAcpiDriver().

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_FAN_HID))
        {
            status = IoRegisterDeviceInterface(DeviceData->Common.Self,
                                               &GUID_DEVICE_FAN,
                                               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 1925 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 327 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 (DeviceData->DockDevice)
        deviceCapabilities->DockDevice = TRUE;
    DPRINT("DockDevice: %u\n", deviceCapabilities->DockDevice);
 
    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 445 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 1834 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 693 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 1313 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 806 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 = (ACPI_RESOURCE_MEMORY32*) &resource->Data;
                ResourceDescriptor->Type = CmResourceTypeMemory;
                ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                ResourceDescriptor->Flags = 0;
                if (mem32_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 = mem32_data->Minimum;
                ResourceDescriptor->u.Memory.Length = mem32_data->AddressLength;
 
                ResourceDescriptor++;
                break;
            }
            case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
            {
                ACPI_RESOURCE_FIXED_MEMORY32 *memfixed32_data = (ACPI_RESOURCE_FIXED_MEMORY32*) &resource->Data;
                ResourceDescriptor->Type = CmResourceTypeMemory;
                ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                ResourceDescriptor->Flags = 0;
                if (memfixed32_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 = memfixed32_data->Address;
                ResourceDescriptor->u.Memory.Length = memfixed32_data->AddressLength;
 
                ResourceDescriptor++;
                break;
            }
            default:
            {
                break;
            }
        }
        resource = ACPI_NEXT_RESOURCE(resource);
    }
 
    ExFreePoolWithTag(Buffer.Pointer, 'BpcA');
    Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
    return STATUS_SUCCESS;
}

Referenced by Bus_PDO_PnP().

Bus_PnP()

NTSTATUS NTAPI Bus_PnP	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 25 of file pnp.c.

{
    PIO_STACK_LOCATION      irpStack;
    NTSTATUS                status;
    PCOMMON_DEVICE_DATA     commonData;
 
    PAGED_CODE ();
 
    irpStack = IoGetCurrentIrpStackLocation (Irp);
    ASSERT (IRP_MJ_PNP == irpStack->MajorFunction);
 
    commonData = (PCOMMON_DEVICE_DATA) DeviceObject->DeviceExtension;
 
 
    if (commonData->IsFDO) {
        DPRINT("FDO %s IRP:0x%p\n",
                      PnPMinorFunctionString(irpStack->MinorFunction),
                      Irp);
        //
        // Request is for the bus FDO
        //
        status = Bus_FDO_PnP (
                    DeviceObject,
                    Irp,
                    irpStack,
                    (PFDO_DEVICE_DATA) commonData);
    } else {
        DPRINT("PDO %s IRP: 0x%p\n",
                      PnPMinorFunctionString(irpStack->MinorFunction),
                      Irp);
        //
        // Request is for the child PDO.
        //
        status = Bus_PDO_PnP (
                    DeviceObject,
                    Irp,
                    irpStack,
                    (PPDO_DEVICE_DATA) commonData);
    }
 
    return status;
}

Referenced by DriverEntry().

Bus_Power()

NTSTATUS NTAPI Bus_Power	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 8 of file power.c.

{
    PIO_STACK_LOCATION  irpStack;
    NTSTATUS            status;
    PCOMMON_DEVICE_DATA commonData;
 
    status = STATUS_SUCCESS;
    irpStack = IoGetCurrentIrpStackLocation (Irp);
    ASSERT (IRP_MJ_POWER == irpStack->MajorFunction);
 
    commonData = (PCOMMON_DEVICE_DATA) DeviceObject->DeviceExtension;
 
    if (commonData->IsFDO) {
 
            DPRINT("FDO %s IRP:0x%p %s %s\n",
            PowerMinorFunctionString(irpStack->MinorFunction), Irp,
            DbgSystemPowerString(commonData->SystemPowerState),
            DbgDevicePowerString(commonData->DevicePowerState));
 
 
        status = Bus_FDO_Power ((PFDO_DEVICE_DATA)DeviceObject->DeviceExtension,
                                Irp);
    } else {
 
            DPRINT("PDO %s IRP:0x%p %s %s\n",
            PowerMinorFunctionString(irpStack->MinorFunction), Irp,
            DbgSystemPowerString(commonData->SystemPowerState),
            DbgDevicePowerString(commonData->DevicePowerState));
 
        status = Bus_PDO_Power ((PPDO_DEVICE_DATA)DeviceObject->DeviceExtension,
                                Irp);
    }
 
    return status;
}

Referenced by DriverEntry().

Bus_RemoveFdo()

void Bus_RemoveFdo

(

PFDO_DEVICE_DATA

FdoData

)

Bus_SendIrpSynchronously()

NTSTATUS Bus_SendIrpSynchronously	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 322 of file pnp.c.

{
    KEVENT   event;
    NTSTATUS status;
 
    PAGED_CODE();
 
    KeInitializeEvent(&event, NotificationEvent, FALSE);
 
    IoCopyCurrentIrpStackLocationToNext(Irp);
 
    IoSetCompletionRoutine(Irp,
                           Bus_CompletionRoutine,
                           &event,
                           TRUE,
                           TRUE,
                           TRUE
                           );
 
    status = IoCallDriver(DeviceObject, Irp);
 
    //
    // Wait for lower drivers to be done with the Irp.
    // 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.
    //
 
    if (status == STATUS_PENDING) {
       KeWaitForSingleObject(&event,
                             Executive,
                             KernelMode,
                             FALSE,
                             NULL
                             );
       status = Irp->IoStatus.Status;
    }
 
    return status;
}

Bus_SetCrispinessLevel()

BOOLEAN Bus_SetCrispinessLevel	(	PVOID	Context,
		UCHAR	Level
	)

Bus_StartFdo()

NTSTATUS Bus_StartFdo	(	PFDO_DEVICE_DATA	FdoData,
		PIRP	Irp
	)

Definition at line 267 of file pnp.c.

{
    NTSTATUS status;
    POWER_STATE powerState;
    ACPI_STATUS AcpiStatus;
 
    PAGED_CODE ();
 
    FdoData->Common.DevicePowerState = PowerDeviceD0;
    powerState.DeviceState = PowerDeviceD0;
    PoSetPowerState ( FdoData->Common.Self, DevicePowerState, powerState );
 
    SET_NEW_PNP_STATE(FdoData->Common, Started);
 
    AcpiStatus = AcpiInitializeSubsystem();
    if(ACPI_FAILURE(AcpiStatus)){
        DPRINT1("Unable to AcpiInitializeSubsystem\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    AcpiStatus = AcpiInitializeTables(NULL, 16, 0);
    if (ACPI_FAILURE(AcpiStatus)){
        DPRINT1("Unable to AcpiInitializeTables\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    AcpiStatus = AcpiLoadTables();
    if(ACPI_FAILURE(AcpiStatus)){
        DPRINT1("Unable to AcpiLoadTables\n");
        AcpiTerminate();
        return STATUS_UNSUCCESSFUL;
    }
 
    status = acpi_create_volatile_registry_tables();
    if (!NT_SUCCESS(status))
    {
        DPRINT1("Unable to create ACPI tables in registry\n");
    }
 
    DPRINT("Acpi subsystem init\n");
    /* Initialize ACPI bus manager */
    AcpiStatus = acpi_init();
    if (!ACPI_SUCCESS(AcpiStatus)) {
        DPRINT1("acpi_init() failed with status 0x%X\n", AcpiStatus);
        AcpiTerminate();
        return STATUS_UNSUCCESSFUL;
    }
    status = ACPIEnumerateDevices(FdoData);
 
    return status;
}

Referenced by Bus_FDO_PnP().

DbgDeviceIDString()

PCHAR DbgDeviceIDString

(

BUS_QUERY_ID_TYPE

Type

)

DbgDevicePowerString()

PCHAR DbgDevicePowerString

(

DEVICE_POWER_STATE

Type

)

Referenced by Bus_FDO_Power(), Bus_PDO_Power(), and Bus_Power().

DbgDeviceRelationString()

PCHAR DbgDeviceRelationString

(

DEVICE_RELATION_TYPE

Type

)

Referenced by Bus_FDO_PnP(), and Bus_PDO_PnP().

DbgSystemPowerString()

PCHAR DbgSystemPowerString

(

SYSTEM_POWER_STATE

Type

)

Referenced by Bus_FDO_Power(), Bus_PDO_Power(), and Bus_Power().

PnPMinorFunctionString()

PCHAR PnPMinorFunctionString

(

UCHAR

MinorFunction

)

Definition at line 1831 of file fbtpnp.c.

{
    switch (MinorFunction)
    {
        case IRP_MN_START_DEVICE:
            return "IRP_MN_START_DEVICE\n";
 
        case IRP_MN_QUERY_REMOVE_DEVICE:
            return "IRP_MN_QUERY_REMOVE_DEVICE\n";
 
        case IRP_MN_REMOVE_DEVICE:
            return "IRP_MN_REMOVE_DEVICE\n";
 
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            return "IRP_MN_CANCEL_REMOVE_DEVICE\n";
 
        case IRP_MN_STOP_DEVICE:
            return "IRP_MN_STOP_DEVICE\n";
 
        case IRP_MN_QUERY_STOP_DEVICE:
            return "IRP_MN_QUERY_STOP_DEVICE\n";
 
        case IRP_MN_CANCEL_STOP_DEVICE:
            return "IRP_MN_CANCEL_STOP_DEVICE\n";
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            return "IRP_MN_QUERY_DEVICE_RELATIONS\n";
 
        case IRP_MN_QUERY_INTERFACE:
            return "IRP_MN_QUERY_INTERFACE\n";
 
        case IRP_MN_QUERY_CAPABILITIES:
            return "IRP_MN_QUERY_CAPABILITIES\n";
 
        case IRP_MN_QUERY_RESOURCES:
            return "IRP_MN_QUERY_RESOURCES\n";
 
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            return "IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n";
 
        case IRP_MN_QUERY_DEVICE_TEXT:
            return "IRP_MN_QUERY_DEVICE_TEXT\n";
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            return "IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n";
 
        case IRP_MN_READ_CONFIG:
            return "IRP_MN_READ_CONFIG\n";
 
        case IRP_MN_WRITE_CONFIG:
            return "IRP_MN_WRITE_CONFIG\n";
 
        case IRP_MN_EJECT:
            return "IRP_MN_EJECT\n";
 
        case IRP_MN_SET_LOCK:
            return "IRP_MN_SET_LOCK\n";
 
        case IRP_MN_QUERY_ID:
            return "IRP_MN_QUERY_ID\n";
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            return "IRP_MN_QUERY_PNP_DEVICE_STATE\n";
 
        case IRP_MN_QUERY_BUS_INFORMATION:
            return "IRP_MN_QUERY_BUS_INFORMATION\n";
 
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            return "IRP_MN_DEVICE_USAGE_NOTIFICATION\n";
 
        case IRP_MN_SURPRISE_REMOVAL:
            return "IRP_MN_SURPRISE_REMOVAL\n";
 
        default:
            return "IRP_MN_?????\n";
 
    }
 
}

Referenced by Bus_PnP(), and FreeBT_DispatchPnP().

PowerMinorFunctionString()

PCHAR PowerMinorFunctionString

(

UCHAR

MinorFunction

)

Variable Documentation

ProcessorHardwareIds

UNICODE_STRING ProcessorHardwareIds

extern

Definition at line 17 of file main.c.

Referenced by Bus_PDO_QueryDeviceId(), and GetProcessorInformation().

ProcessorIdString

LPWSTR ProcessorIdString

extern

Definition at line 18 of file main.c.

Referenced by Bus_PDO_QueryDeviceId(), and GetProcessorInformation().

ProcessorNameString

LPWSTR ProcessorNameString

extern

Definition at line 19 of file main.c.

Referenced by Bus_PDO_QueryDeviceText(), and GetProcessorInformation().