Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-24 17:34:57 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fixes for APCI bus driver.

Browse source 
svn path=/trunk/; revision=2194
This commit is contained in:
Casper Hornstrup 2001-08-23 17:32:04 +00:00
parent c5d8547022
commit 5d518a1695
7 changed files with 907 additions and 480 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
reactos/drivers/bus/acpi/makefile
View file

@ -1,4 +1,4 @@
# $Id: makefile,v 1.6 2001/08/21 20:13:10 chorns Exp $
# $Id: makefile,v 1.7 2001/08/23 17:32:03 chorns Exp $
PATH_TO_TOP = ../../..
@ -42,7 +42,9 @@ OBJECTS_OSPM = \
ospm/acpienum.o \
ospm/acpisys.o \
ospm/bn.o \
ospm/osl.o
ospm/fdo.o \
ospm/osl.o \
ospm/pdo.o
OBJECTS_DISPATCHER = \
dispatcher/dsfield.o \

50
reactos/drivers/bus/acpi/ospm/acpienum.c
View file

@ -1,4 +1,4 @@
/* $Id: acpienum.c,v 1.2 2001/05/05 19:15:44 chorns Exp $
/* $Id: acpienum.c,v 1.3 2001/08/23 17:32:04 chorns Exp $
*
* PROJECT: ReactOS ACPI bus driver
* FILE: acpi/ospm/acpienum.c
@ -104,7 +104,7 @@ bm_print1 (
NTSTATUS
ACPIEnumerateRootBusses(
PACPI_DEVICE_EXTENSION DeviceExtension)
PFDO_DEVICE_EXTENSION DeviceExtension)
{
BM_HANDLE_LIST HandleList;
PACPI_DEVICE AcpiDevice;
@ -132,7 +132,7 @@ ACPIEnumerateRootBusses(
if (ACPI_SUCCESS(AcpiStatus)) {
DPRINT("Got BM node information: (Node 0x%X)\n", Node);
bm_print1(Node, BM_PRINT_ALL - BM_PRINT_PRESENT);
#if 0
#if 1
for (j=0; j < 4*1000;j++)
KeStallExecutionProcessor(1000);
#endif
@ -146,6 +146,8 @@ ACPIEnumerateRootBusses(
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(AcpiDevice, sizeof(ACPI_DEVICE));
AcpiDevice->Pdo = NULL;
AcpiDevice->BmHandle = HandleList.handles[i];
@ -158,6 +160,8 @@ ACPIEnumerateRootBusses(
} else {
DPRINT("Got no devices (Status 0x%X)\n", AcpiStatus);
}
for (j=0; j < 4*10*1000;j++)
KeStallExecutionProcessor(1000);
return STATUS_SUCCESS;
}
@ -165,15 +169,16 @@ ACPIEnumerateRootBusses(
NTSTATUS
ACPIEnumerateNamespace(
PACPI_DEVICE_EXTENSION DeviceExtension)
PFDO_DEVICE_EXTENSION DeviceExtension)
{
ACPI_STATUS AcpiStatus;
BM_DEVICE_ID Criteria;
BM_HANDLE_LIST HandleList;
ULONG i;
PACPI_DEVICE AcpiDevice;
ACPI_STATUS AcpiStatus;
BM_HANDLE DeviceHandle;
BM_DEVICE_ID Criteria;
BM_NODE *Node;
ULONG j, q;
KIRQL OldIrql;
ULONG i;
DPRINT("Called\n");
@ -191,13 +196,34 @@ ACPIEnumerateNamespace(
if (ACPI_SUCCESS(AcpiStatus)) {
DPRINT("Got BM node information: (Node 0x%X)\n", Node);
#if 0
bm_print1(Node, BM_PRINT_ALL - BM_PRINT_PRESENT);
for (j=0; j < 4*1000;j++)
KeStallExecutionProcessor(1000);*/
{
ULONG j;
bm_print1(Node, BM_PRINT_ALL - BM_PRINT_PRESENT);
for (j=0; j < 4*1000;j++)
KeStallExecutionProcessor(1000);
}
#endif
} else {
DPRINT("Could not get BM node\n");
}
AcpiDevice = (PACPI_DEVICE)ExAllocatePool(
NonPagedPool, sizeof(ACPI_DEVICE));
if (!AcpiDevice) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(AcpiDevice, sizeof(ACPI_DEVICE));
AcpiDevice->Pdo = NULL;
AcpiDevice->BmHandle = HandleList.handles[i];
KeAcquireSpinLock(&DeviceExtension->DeviceListLock, &OldIrql);
InsertHeadList(&DeviceExtension->DeviceListHead,
&AcpiDevice->DeviceListEntry);
DeviceExtension->DeviceListCount++;
KeReleaseSpinLock(&DeviceExtension->DeviceListLock, OldIrql);
}
} else {
DPRINT("Got no devices (Status 0x%X)\n", AcpiStatus);

430
reactos/drivers/bus/acpi/ospm/acpisys.c
View file

@ -1,4 +1,4 @@
/* $Id: acpisys.c,v 1.2 2001/05/05 19:15:44 chorns Exp $
/* $Id: acpisys.c,v 1.3 2001/08/23 17:32:04 chorns Exp $
*
* PROJECT: ReactOS ACPI bus driver
* FILE: acpi/ospm/acpisys.c
@ -23,8 +23,6 @@
#endif /* ALLOC_PRAGMA */
FADT_DESCRIPTOR_REV2 acpi_fadt;
NTSTATUS
STDCALL
@ -61,401 +59,33 @@ ACPIDispatchDeviceControl(
}
VOID ACPIPrintInfo(
PACPI_DEVICE_EXTENSION DeviceExtension)
{
DbgPrint("ACPI: System firmware supports:\n");
/*
* Print out basic system information
*/
DbgPrint("+------------------------------------------------------------\n");
DbgPrint("| Sx states: %cS0 %cS1 %cS2 %cS3 %cS4 %cS5\n",
(DeviceExtension->SystemStates[0]?'+':'-'),
(DeviceExtension->SystemStates[1]?'+':'-'),
(DeviceExtension->SystemStates[2]?'+':'-'),
(DeviceExtension->SystemStates[3]?'+':'-'),
(DeviceExtension->SystemStates[4]?'+':'-'),
(DeviceExtension->SystemStates[5]?'+':'-'));
DbgPrint("+------------------------------------------------------------\n");
}
NTSTATUS
ACPIInitializeInternalDriver(
PACPI_DEVICE_EXTENSION DeviceExtension,
ACPI_DRIVER_FUNCTION Initialize,
ACPI_DRIVER_FUNCTION Terminate)
{
ACPI_STATUS AcpiStatus;
PACPI_DEVICE AcpiDevice;
AcpiStatus = Initialize();
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("BN init status 0x%X\n", AcpiStatus);
return STATUS_UNSUCCESSFUL;
}
#if 0
AcpiDevice = (PACPI_DEVICE)ExAllocatePool(
NonPagedPool, sizeof(ACPI_DEVICE));
if (!AcpiDevice) {
return STATUS_INSUFFICIENT_RESOURCES;
}
AcpiDevice->Initialize = Initialize;
AcpiDevice->Terminate = Terminate;
/* FIXME: Create PDO */
AcpiDevice->Pdo = NULL;
//AcpiDevice->BmHandle = HandleList.handles[i];
ExInterlockedInsertHeadList(&DeviceExtension->DeviceListHead,
&AcpiDevice->ListEntry, &DeviceExtension->DeviceListLock);
#endif
return STATUS_SUCCESS;
}
NTSTATUS
ACPIInitializeInternalDrivers(
PACPI_DEVICE_EXTENSION DeviceExtension)
{
NTSTATUS Status;
ULONG j;
Status = ACPIInitializeInternalDriver(DeviceExtension,
bn_initialize, bn_terminate);
return STATUS_SUCCESS;
}
NTSTATUS
ACPIStartDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PACPI_DEVICE_EXTENSION DeviceExtension;
ACPI_PHYSICAL_ADDRESS rsdp;
ACPI_SYSTEM_INFO SysInfo;
ACPI_STATUS AcpiStatus;
ACPI_BUFFER Buffer;
UCHAR TypeA, TypeB;
ULONG i;
DPRINT("Called\n");
DeviceExtension = (PACPI_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
assert(DeviceExtension->State == dsStopped);
AcpiStatus = acpi_initialize_subsystem();
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_initialize_subsystem() failed with status 0x%X\n", AcpiStatus);
return STATUS_UNSUCCESSFUL;
}
AcpiStatus = acpi_find_root_pointer(&rsdp);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_find_root_pointer() failed with status 0x%X\n", AcpiStatus);
return STATUS_UNSUCCESSFUL;
}
/* From this point on, on error we must call acpi_terminate() */
AcpiStatus = acpi_load_tables(rsdp);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_load_tables() failed with status 0x%X\n", AcpiStatus);
acpi_terminate();
return STATUS_UNSUCCESSFUL;
}
Buffer.length = sizeof(SysInfo);
Buffer.pointer = &SysInfo;
AcpiStatus = acpi_get_system_info(&Buffer);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_get_system_info() failed with status 0x%X\n", AcpiStatus);
acpi_terminate();
return STATUS_UNSUCCESSFUL;
}
DPRINT("ACPI CA Core Subsystem version 0x%X\n", SysInfo.acpi_ca_version);
assert(SysInfo.num_table_types > ACPI_TABLE_FADT);
RtlMoveMemory(&acpi_fadt,
&SysInfo.table_info[ACPI_TABLE_FADT],
sizeof(FADT_DESCRIPTOR_REV2));
AcpiStatus = acpi_enable_subsystem(ACPI_FULL_INITIALIZATION);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_enable_subsystem() failed with status 0x%X\n", AcpiStatus);
acpi_terminate();
return STATUS_UNSUCCESSFUL;
}
DPRINT("ACPI CA Core Subsystem enabled\n");
/*
* Sx States:
* ----------
* Figure out which Sx states are supported
*/
for (i=0; i<=ACPI_S_STATES_MAX; i++) {
AcpiStatus = acpi_hw_obtain_sleep_type_register_data(
i,
&TypeA,
&TypeB);
DPRINT("acpi_hw_obtain_sleep_type_register_data (%d) status 0x%X\n",
i, AcpiStatus);
if (ACPI_SUCCESS(AcpiStatus)) {
DeviceExtension->SystemStates[i] = TRUE;
}
}
ACPIPrintInfo(DeviceExtension);
/* Initialize ACPI bus manager */
AcpiStatus = bm_initialize();
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("bm_initialize() failed with status 0x%X\n", AcpiStatus);
acpi_terminate();
return STATUS_UNSUCCESSFUL;
}
InitializeListHead(&DeviceExtension->DeviceListHead);
KeInitializeSpinLock(&DeviceExtension->DeviceListLock);
DeviceExtension->DeviceListCount = 0;
ACPIEnumerateNamespace(DeviceExtension);
ACPIEnumerateRootBusses(DeviceExtension);
ACPIInitializeInternalDrivers(DeviceExtension);
DeviceExtension->State = dsStarted;
return STATUS_SUCCESS;
}
NTSTATUS
ACPIQueryBusRelations(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PACPI_DEVICE_EXTENSION DeviceExtension;
PDEVICE_RELATIONS Relations;
PLIST_ENTRY CurrentEntry;
PACPI_DEVICE Device;
NTSTATUS Status;
ULONG Size;
ULONG i;
DPRINT("Called\n");
DeviceExtension = (PACPI_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
Size = sizeof(DEVICE_RELATIONS) + sizeof(Relations->Objects) *
(DeviceExtension->DeviceListCount - 1);
Relations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool, Size);
if (!Relations)
return STATUS_INSUFFICIENT_RESOURCES;
Relations->Count = DeviceExtension->DeviceListCount;
i = 0;
CurrentEntry = DeviceExtension->DeviceListHead.Flink;
while (CurrentEntry != &DeviceExtension->DeviceListHead) {
Device = CONTAINING_RECORD(CurrentEntry, ACPI_DEVICE, DeviceListEntry);
/* FIXME: For ACPI namespace devices on the motherboard create filter DOs
and attach them just above the ACPI bus device object (PDO) */
/* FIXME: For other devices in ACPI namespace, but not on motherboard,
create PDOs */
if (!Device->Pdo) {
/* Create a physical device object for the
device as it does not already have one */
Status = IoCreateDevice(DeviceObject->DriverObject, 0,
NULL, FILE_DEVICE_CONTROLLER, 0, FALSE, &Device->Pdo);
if (!NT_SUCCESS(Status)) {
DPRINT("IoCreateDevice() failed with status 0x%X\n", Status);
ExFreePool(Relations);
return Status;
}
Device->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
}
/* Reference the physical device object. The PnP manager
will dereference it again when it is no longer needed */
ObReferenceObject(Device->Pdo);
Relations->Objects[i] = Device->Pdo;
i++;
CurrentEntry = CurrentEntry->Flink;
}
Irp->IoStatus.Information = (ULONG)Relations;
return Status;
}
NTSTATUS
ACPIQueryDeviceRelations(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
NTSTATUS Status;
DPRINT("Called\n");
switch (IrpSp->Parameters.QueryDeviceRelations.Type) {
case BusRelations:
Status = ACPIQueryBusRelations(DeviceObject, Irp, IrpSp);
break;
default:
Status = STATUS_NOT_IMPLEMENTED;
}
return Status;
}
NTSTATUS
ACPIQueryId(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
NTSTATUS Status;
DPRINT("Called\n");
switch (IrpSp->Parameters.QueryId.IdType) {
default:
Status = STATUS_NOT_IMPLEMENTED;
}
return Status;
}
NTSTATUS
ACPISetPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PACPI_DEVICE_EXTENSION DeviceExtension;
ACPI_STATUS AcpiStatus;
NTSTATUS Status;
ULONG AcpiState;
DPRINT("Called\n");
DeviceExtension = (PACPI_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
if (IrpSp->Parameters.Power.Type == SystemPowerState) {
Status = STATUS_SUCCESS;
switch (IrpSp->Parameters.Power.State.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:
Status = STATUS_UNSUCCESSFUL;
}
if (!DeviceExtension->SystemStates[AcpiState]) {
DPRINT("System sleep state S%d is not supported by hardware\n", AcpiState);
Status = STATUS_UNSUCCESSFUL;
}
if (NT_SUCCESS(Status)) {
DPRINT("Trying to enter sleep state %d\n", AcpiState);
AcpiStatus = acpi_enter_sleep_state(AcpiState);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("Failed to enter sleep state %d (Status 0x%X)\n",
AcpiState, AcpiStatus);
Status = STATUS_UNSUCCESSFUL;
}
}
} else {
Status = STATUS_UNSUCCESSFUL;
}
return Status;
}
NTSTATUS
STDCALL
ACPIPnpControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
/*
* FUNCTION: Handle Plug and Play IRPs
* ARGUMENTS:
* DeviceObject = Pointer to PDO or FDO
* Irp = Pointer to IRP that should be handled
* RETURNS:
* Status
*/
{
PIO_STACK_LOCATION IrpSp;
PCOMMON_DEVICE_EXTENSION DeviceExtension;
NTSTATUS Status;
DPRINT("Called\n");
IrpSp = IoGetCurrentIrpStackLocation(Irp);
switch (IrpSp->MinorFunction) {
case IRP_MN_QUERY_DEVICE_RELATIONS:
Status = ACPIQueryDeviceRelations(DeviceObject, Irp, IrpSp);
break;
DeviceExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
case IRP_MN_QUERY_ID:
Status = ACPIQueryId(DeviceObject, Irp, IrpSp);
break;
case IRP_MN_START_DEVICE:
DPRINT("IRP_MN_START_DEVICE received\n");
Status = ACPIStartDevice(DeviceObject, Irp);
break;
case IRP_MN_STOP_DEVICE:
/* Currently not supported */
//bm_terminate();
Status = STATUS_UNSUCCESSFUL;
break;
default:
DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
Status = STATUS_NOT_IMPLEMENTED;
break;
if (DeviceExtension->IsFDO) {
Status = FdoPnpControl(DeviceObject, Irp);
} else {
Status = FdoPnpControl(DeviceObject, Irp);
}
if (Status != STATUS_PENDING) {
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
DPRINT("Leaving. Status 0x%X\n", Status);
return Status;
}
@ -466,31 +96,19 @@ ACPIPowerControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PIO_STACK_LOCATION IrpSp;
PCOMMON_DEVICE_EXTENSION DeviceExtension;
NTSTATUS Status;
DPRINT("Called\n");
IrpSp = IoGetCurrentIrpStackLocation(Irp);
DeviceExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
switch (IrpSp->MinorFunction) {
case IRP_MN_SET_POWER:
Status = ACPISetPower(DeviceObject, Irp, IrpSp);
break;
default:
DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
Status = STATUS_NOT_IMPLEMENTED;
break;
if (DeviceExtension->IsFDO) {
Status = FdoPowerControl(DeviceObject, Irp);
} else {
Status = PdoPowerControl(DeviceObject, Irp);
}
if (Status != STATUS_PENDING) {
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
DPRINT("Leaving. Status 0x%X\n", Status);
return Status;
}
@ -500,20 +118,20 @@ ACPIAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject)
{
PACPI_DEVICE_EXTENSION DeviceExtension;
PFDO_DEVICE_EXTENSION DeviceExtension;
PDEVICE_OBJECT Fdo;
NTSTATUS Status;
DPRINT("Called\n");
Status = IoCreateDevice(DriverObject, sizeof(ACPI_DEVICE_EXTENSION),
Status = IoCreateDevice(DriverObject, sizeof(FDO_DEVICE_EXTENSION),
NULL, FILE_DEVICE_ACPI, FILE_DEVICE_SECURE_OPEN, TRUE, &Fdo);
if (!NT_SUCCESS(Status)) {
DPRINT("IoCreateDevice() failed with status 0x%X\n", Status);
return Status;
}
DeviceExtension = (PACPI_DEVICE_EXTENSION)Fdo->DeviceExtension;
DeviceExtension = (PFDO_DEVICE_EXTENSION)Fdo->DeviceExtension;
DeviceExtension->Pdo = PhysicalDeviceObject;

512
reactos/drivers/bus/acpi/ospm/fdo.c Normal file
View file

@ -0,0 +1,512 @@
/* $Id: fdo.c,v 1.1 2001/08/23 17:32:04 chorns Exp $
*
* PROJECT: ReactOS ACPI bus driver
* FILE: acpi/ospm/fdo.c
* PURPOSE: ACPI device object dispatch routines
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* UPDATE HISTORY:
* 08-08-2001 CSH Created
*/
#include <acpisys.h>
#include <bm.h>
#include <bn.h>
#define NDEBUG
#include <debug.h>
/*** PRIVATE *****************************************************************/
FADT_DESCRIPTOR_REV2 acpi_fadt;
NTSTATUS
FdoQueryBusRelations(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PPDO_DEVICE_EXTENSION PdoDeviceExtension;
PFDO_DEVICE_EXTENSION DeviceExtension;
PDEVICE_RELATIONS Relations;
PLIST_ENTRY CurrentEntry;
ANSI_STRING AnsiString;
ACPI_STATUS AcpiStatus;
PACPI_DEVICE Device;
NTSTATUS Status;
BM_NODE *Node;
ULONG Size;
ULONG i;
DPRINT("Called\n");
DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
Size = sizeof(DEVICE_RELATIONS) + sizeof(Relations->Objects) *
(DeviceExtension->DeviceListCount - 1);
Relations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool, Size);
if (!Relations)
return STATUS_INSUFFICIENT_RESOURCES;
Relations->Count = DeviceExtension->DeviceListCount;
i = 0;
CurrentEntry = DeviceExtension->DeviceListHead.Flink;
while (CurrentEntry != &DeviceExtension->DeviceListHead) {
Device = CONTAINING_RECORD(CurrentEntry, ACPI_DEVICE, DeviceListEntry);
/* FIXME: For ACPI namespace devices on the motherboard create filter DOs
and attach them just above the ACPI bus device object (PDO) */
/* FIXME: For other devices in ACPI namespace, but not on motherboard,
create PDOs */
if (!Device->Pdo) {
/* Create a physical device object for the
device as it does not already have one */
Status = IoCreateDevice(DeviceObject->DriverObject, 0,
NULL, FILE_DEVICE_CONTROLLER, 0, FALSE, &Device->Pdo);
if (!NT_SUCCESS(Status)) {
DPRINT("IoCreateDevice() failed with status 0x%X\n", Status);
/* FIXME: Cleanup all new PDOs created in this call */
ExFreePool(Relations);
return Status;
}
PdoDeviceExtension = ExAllocatePool(
NonPagedPool,
sizeof(PDO_DEVICE_EXTENSION));
if (!PdoDeviceExtension) {
/* FIXME: Cleanup all new PDOs created in this call */
ExFreePool(Relations);
}
RtlZeroMemory(
PdoDeviceExtension,
sizeof(PDO_DEVICE_EXTENSION));
Device->Pdo->DeviceExtension = PdoDeviceExtension;
Device->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
PdoDeviceExtension->DeviceObject = Device->Pdo;
PdoDeviceExtension->DevicePowerState = PowerDeviceD0;
PdoDeviceExtension->Ldo = IoAttachDeviceToDeviceStack(
DeviceObject,
Device->Pdo);
RtlInitUnicodeString(&PdoDeviceExtension->HardwareIDs, NULL);
RtlInitUnicodeString(&PdoDeviceExtension->CompatibleIDs, NULL);
AcpiStatus = bm_get_node(Device->BmHandle, 0, &Node);
if (ACPI_SUCCESS(AcpiStatus)) {
if (Node->device.flags & BM_FLAGS_HAS_A_HID) {
RtlInitAnsiString(&AnsiString, Node->device.id.hid);
Status = RtlAnsiStringToUnicodeString(
&PdoDeviceExtension->HardwareIDs,
&AnsiString,
TRUE);
assert(NT_SUCCESS(Status));
}
if (Node->device.flags & BM_FLAGS_HAS_A_CID) {
RtlInitAnsiString(&AnsiString, Node->device.id.cid);
Status = RtlAnsiStringToUnicodeString(
&PdoDeviceExtension->CompatibleIDs,
&AnsiString,
TRUE);
assert(NT_SUCCESS(Status));
}
}
}
/* Reference the physical device object. The PnP manager
will dereference it again when it is no longer needed */
ObReferenceObject(Device->Pdo);
Relations->Objects[i] = Device->Pdo;
i++;
CurrentEntry = CurrentEntry->Flink;
}
Irp->IoStatus.Information = (ULONG)Relations;
return Status;
}
VOID ACPIPrintInfo(
PFDO_DEVICE_EXTENSION DeviceExtension)
{
DbgPrint("ACPI: System firmware supports:\n");
/*
* Print out basic system information
*/
DbgPrint("+------------------------------------------------------------\n");
DbgPrint("| Sx states: %cS0 %cS1 %cS2 %cS3 %cS4 %cS5\n",
(DeviceExtension->SystemStates[0]?'+':'-'),
(DeviceExtension->SystemStates[1]?'+':'-'),
(DeviceExtension->SystemStates[2]?'+':'-'),
(DeviceExtension->SystemStates[3]?'+':'-'),
(DeviceExtension->SystemStates[4]?'+':'-'),
(DeviceExtension->SystemStates[5]?'+':'-'));
DbgPrint("+------------------------------------------------------------\n");
}
NTSTATUS
ACPIInitializeInternalDriver(
PFDO_DEVICE_EXTENSION DeviceExtension,
ACPI_DRIVER_FUNCTION Initialize,
ACPI_DRIVER_FUNCTION Terminate)
{
ACPI_STATUS AcpiStatus;
PACPI_DEVICE AcpiDevice;
AcpiStatus = Initialize();
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("BN init status 0x%X\n", AcpiStatus);
return STATUS_UNSUCCESSFUL;
}
#if 0
AcpiDevice = (PACPI_DEVICE)ExAllocatePool(
NonPagedPool, sizeof(ACPI_DEVICE));
if (!AcpiDevice) {
return STATUS_INSUFFICIENT_RESOURCES;
}
AcpiDevice->Initialize = Initialize;
AcpiDevice->Terminate = Terminate;
/* FIXME: Create PDO */
AcpiDevice->Pdo = NULL;
//AcpiDevice->BmHandle = HandleList.handles[i];
ExInterlockedInsertHeadList(&DeviceExtension->DeviceListHead,
&AcpiDevice->ListEntry, &DeviceExtension->DeviceListLock);
#endif
return STATUS_SUCCESS;
}
NTSTATUS
ACPIInitializeInternalDrivers(
PFDO_DEVICE_EXTENSION DeviceExtension)
{
NTSTATUS Status;
ULONG j;
Status = ACPIInitializeInternalDriver(DeviceExtension,
bn_initialize, bn_terminate);
return STATUS_SUCCESS;
}
NTSTATUS
FdoStartDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PFDO_DEVICE_EXTENSION DeviceExtension;
ACPI_PHYSICAL_ADDRESS rsdp;
ACPI_SYSTEM_INFO SysInfo;
ACPI_STATUS AcpiStatus;
ACPI_BUFFER Buffer;
UCHAR TypeA, TypeB;
ULONG i;
DPRINT("Called\n");
DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
assert(DeviceExtension->State == dsStopped);
AcpiStatus = acpi_initialize_subsystem();
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_initialize_subsystem() failed with status 0x%X\n", AcpiStatus);
return STATUS_UNSUCCESSFUL;
}
AcpiStatus = acpi_find_root_pointer(&rsdp);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_find_root_pointer() failed with status 0x%X\n", AcpiStatus);
return STATUS_UNSUCCESSFUL;
}
/* From this point on, on error we must call acpi_terminate() */
AcpiStatus = acpi_load_tables(rsdp);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_load_tables() failed with status 0x%X\n", AcpiStatus);
acpi_terminate();
return STATUS_UNSUCCESSFUL;
}
Buffer.length = sizeof(SysInfo);
Buffer.pointer = &SysInfo;
AcpiStatus = acpi_get_system_info(&Buffer);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_get_system_info() failed with status 0x%X\n", AcpiStatus);
acpi_terminate();
return STATUS_UNSUCCESSFUL;
}
DPRINT("ACPI CA Core Subsystem version 0x%X\n", SysInfo.acpi_ca_version);
assert(SysInfo.num_table_types > ACPI_TABLE_FADT);
RtlMoveMemory(&acpi_fadt,
&SysInfo.table_info[ACPI_TABLE_FADT],
sizeof(FADT_DESCRIPTOR_REV2));
AcpiStatus = acpi_enable_subsystem(ACPI_FULL_INITIALIZATION);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("acpi_enable_subsystem() failed with status 0x%X\n", AcpiStatus);
acpi_terminate();
return STATUS_UNSUCCESSFUL;
}
DPRINT("ACPI CA Core Subsystem enabled\n");
/*
* Sx States:
* ----------
* Figure out which Sx states are supported
*/
for (i=0; i<=ACPI_S_STATES_MAX; i++) {
AcpiStatus = acpi_hw_obtain_sleep_type_register_data(
i,
&TypeA,
&TypeB);
DPRINT("acpi_hw_obtain_sleep_type_register_data (%d) status 0x%X\n",
i, AcpiStatus);
if (ACPI_SUCCESS(AcpiStatus)) {
DeviceExtension->SystemStates[i] = TRUE;
}
}
ACPIPrintInfo(DeviceExtension);
/* Initialize ACPI bus manager */
AcpiStatus = bm_initialize();
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("bm_initialize() failed with status 0x%X\n", AcpiStatus);
acpi_terminate();
return STATUS_UNSUCCESSFUL;
}
InitializeListHead(&DeviceExtension->DeviceListHead);
KeInitializeSpinLock(&DeviceExtension->DeviceListLock);
DeviceExtension->DeviceListCount = 0;
ACPIEnumerateNamespace(DeviceExtension);
//ACPIEnumerateRootBusses(DeviceExtension);
ACPIInitializeInternalDrivers(DeviceExtension);
DeviceExtension->State = dsStarted;
return STATUS_SUCCESS;
}
NTSTATUS
FdoSetPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PFDO_DEVICE_EXTENSION DeviceExtension;
ACPI_STATUS AcpiStatus;
NTSTATUS Status;
ULONG AcpiState;
DPRINT("Called\n");
DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
if (IrpSp->Parameters.Power.Type == SystemPowerState) {
Status = STATUS_SUCCESS;
switch (IrpSp->Parameters.Power.State.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:
Status = STATUS_UNSUCCESSFUL;
}
if (!DeviceExtension->SystemStates[AcpiState]) {
DPRINT("System sleep state S%d is not supported by hardware\n", AcpiState);
Status = STATUS_UNSUCCESSFUL;
}
if (NT_SUCCESS(Status)) {
DPRINT("Trying to enter sleep state %d\n", AcpiState);
AcpiStatus = acpi_enter_sleep_state(AcpiState);
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT("Failed to enter sleep state %d (Status 0x%X)\n",
AcpiState, AcpiStatus);
Status = STATUS_UNSUCCESSFUL;
}
}
} else {
Status = STATUS_UNSUCCESSFUL;
}
return Status;
}
/*** PUBLIC ******************************************************************/
NTSTATUS
STDCALL
FdoPnpControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
* FUNCTION: Handle Plug and Play IRPs for the ACPI device
* ARGUMENTS:
* DeviceObject = Pointer to functional device object of the ACPI driver
* Irp = Pointer to IRP that should be handled
* RETURNS:
* Status
*/
{
PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
DPRINT("Called\n");
IrpSp = IoGetCurrentIrpStackLocation(Irp);
switch (IrpSp->MinorFunction) {
case IRP_MN_CANCEL_REMOVE_DEVICE:
Status = STATUS_NOT_IMPLEMENTED;
break;
case IRP_MN_CANCEL_STOP_DEVICE:
Status = STATUS_NOT_IMPLEMENTED;
break;
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
Status = STATUS_NOT_IMPLEMENTED;
break;
case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
Status = STATUS_NOT_IMPLEMENTED;
break;
case IRP_MN_QUERY_DEVICE_RELATIONS:
Status = FdoQueryBusRelations(DeviceObject, Irp, IrpSp);
break;
case IRP_MN_QUERY_PNP_DEVICE_STATE:
Status = STATUS_NOT_IMPLEMENTED;
break;
case IRP_MN_QUERY_REMOVE_DEVICE:
Status = STATUS_NOT_IMPLEMENTED;
break;
case IRP_MN_QUERY_STOP_DEVICE:
Status = STATUS_NOT_IMPLEMENTED;
break;
case IRP_MN_REMOVE_DEVICE:
Status = STATUS_NOT_IMPLEMENTED;
break;
case IRP_MN_START_DEVICE:
DPRINT("IRP_MN_START_DEVICE received\n");
Status = FdoStartDevice(DeviceObject, Irp);
break;
case IRP_MN_STOP_DEVICE:
/* Currently not supported */
//bm_terminate();
Status = STATUS_UNSUCCESSFUL;
break;
case IRP_MN_SURPRISE_REMOVAL:
Status = STATUS_NOT_IMPLEMENTED;
break;
default:
DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
Status = STATUS_NOT_IMPLEMENTED;
break;
}
if (Status != STATUS_PENDING) {
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
DPRINT("Leaving. Status 0x%X\n", Status);
return Status;
}
NTSTATUS
STDCALL
FdoPowerControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
* FUNCTION: Handle power management IRPs for the ACPI device
* ARGUMENTS:
* DeviceObject = Pointer to functional device object of the ACPI driver
* Irp = Pointer to IRP that should be handled
* RETURNS:
* Status
*/
{
PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
DPRINT("Called\n");
IrpSp = IoGetCurrentIrpStackLocation(Irp);
switch (IrpSp->MinorFunction) {
case IRP_MN_SET_POWER:
Status = FdoSetPower(DeviceObject, Irp, IrpSp);
break;
default:
DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
Status = STATUS_NOT_IMPLEMENTED;
break;
}
if (Status != STATUS_PENDING) {
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
DPRINT("Leaving. Status 0x%X\n", Status);
return Status;
}
/* EOF */

102
reactos/drivers/bus/acpi/ospm/include/acpisys.h
View file

@ -16,9 +16,57 @@ typedef ACPI_STATUS (*ACPI_DRIVER_FUNCTION)(VOID);
typedef enum {
dsStopped,
dsStarted
dsStarted,
dsPaused,
dsRemoved,
dsSurpriseRemoved
} ACPI_DEVICE_STATE;
typedef struct _COMMON_DEVICE_EXTENSION
{
// Pointer to device object, this device extension is associated with
PDEVICE_OBJECT DeviceObject;
// Wether this device extension is for an FDO or PDO
BOOLEAN IsFDO;
// Wether the device is removed
BOOLEAN Removed;
// Current device power state for the device
DEVICE_POWER_STATE DevicePowerState;
// Lower device object
PDEVICE_OBJECT Ldo;
} COMMON_DEVICE_EXTENSION, *PCOMMON_DEVICE_EXTENSION;
/* Physical Device Object device extension for a child device */
typedef struct _PDO_DEVICE_EXTENSION
{
// Common device data
COMMON_DEVICE_EXTENSION;
// Hardware IDs
UNICODE_STRING HardwareIDs;
// Compatible IDs
UNICODE_STRING CompatibleIDs;
} PDO_DEVICE_EXTENSION, *PPDO_DEVICE_EXTENSION;
typedef struct _FDO_DEVICE_EXTENSION
{
// Common device data
COMMON_DEVICE_EXTENSION;
// Physical Device Object
PDEVICE_OBJECT Pdo;
// Current state of the driver
ACPI_DEVICE_STATE State;
// Supported system states
BOOLEAN SystemStates[ACPI_S_STATE_COUNT];
// Namespace device list
LIST_ENTRY DeviceListHead;
// Number of devices in device list
ULONG DeviceListCount;
// Lock for namespace device list
KSPIN_LOCK DeviceListLock;
} FDO_DEVICE_EXTENSION, *PFDO_DEVICE_EXTENSION;
typedef struct _ACPI_DEVICE
{
// Entry on device list
@ -33,30 +81,44 @@ typedef struct _ACPI_DEVICE
ACPI_DRIVER_FUNCTION Terminate;
} ACPI_DEVICE, *PACPI_DEVICE;
typedef struct _ACPI_DEVICE_EXTENSION
{
// Physical Device Object
PDEVICE_OBJECT Pdo;
// Lower device object
PDEVICE_OBJECT Ldo;
// Current state of the driver
ACPI_DEVICE_STATE State;
// Supported system states
BOOLEAN SystemStates[ACPI_S_STATE_COUNT];
// Namespace device list
LIST_ENTRY DeviceListHead;
// Number of devices in device list
ULONG DeviceListCount;
// Lock for namespace device list
KSPIN_LOCK DeviceListLock;
} ACPI_DEVICE_EXTENSION, *PACPI_DEVICE_EXTENSION;
/* acpienum.c */
NTSTATUS
ACPIEnumerateRootBusses(
PACPI_DEVICE_EXTENSION DeviceExtension);
PFDO_DEVICE_EXTENSION DeviceExtension);
NTSTATUS
ACPIEnumerateNamespace(
PACPI_DEVICE_EXTENSION DeviceExtension);
PFDO_DEVICE_EXTENSION DeviceExtension);
/* fdo.c */
NTSTATUS
STDCALL
FdoPnpControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
NTSTATUS
STDCALL
FdoPowerControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
/* pdo.c */
NTSTATUS
STDCALL
PdoPnpControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
NTSTATUS
STDCALL
PdoPowerControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
/* EOF */

66
reactos/drivers/bus/acpi/ospm/osl.c
View file

@ -27,22 +27,33 @@
#define NDEBUG
#include <debug.h>
typedef struct _ACPI_OS_DPC
{
OSD_EXECUTION_CALLBACK Routine;
PVOID Context;
} ACPI_OS_DPC, *PACPI_OS_DPC;
static PKINTERRUPT AcpiInterrupt;
static BOOLEAN AcpiInterruptHandlerRegistered = FALSE;
static OSD_HANDLER AcpiIrqHandler = NULL;
static PVOID AcpiIrqContext = NULL;
static ULONG AcpiIrqNumber = 0;
static KDPC AcpiDpc;
static PVOID IVTVirtualAddress = NULL;
static PVOID BDAVirtualAddress = NULL;
VOID
OslDpcStub(
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2)
{
OSD_EXECUTION_CALLBACK Routine = (OSD_EXECUTION_CALLBACK)SystemArgument1;
DPRINT("OslDpcStub()\n");
DPRINT("Calling [%p]([%p])\n", Routine, SystemArgument2);
(*Routine)(SystemArgument2);
}
ACPI_STATUS
acpi_os_remove_interrupt_handler(
u32 irq,
@ -54,6 +65,8 @@ acpi_os_initialize(void)
{
DPRINT("acpi_os_initialize()\n");
KeInitializeDpc(&AcpiDpc, OslDpcStub, NULL);
return AE_OK;
}
@ -444,32 +457,12 @@ acpi_os_unload_module (
return AE_OK;
}
VOID
OslDpcStub(
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2)
{
PACPI_OS_DPC DpcContext = (PACPI_OS_DPC)DeferredContext;
DPRINT("OslDpcStub()\n");
DPRINT("Calling [%p]([%p])\n", DpcContext->Routine, DpcContext->Context);
(*DpcContext->Routine)(DpcContext->Context);
ExFreePool(Dpc);
}
ACPI_STATUS
acpi_os_queue_for_execution(
u32 priority,
OSD_EXECUTION_CALLBACK function,
void *context)
{
PKDPC Dpc;
PACPI_OS_DPC DpcContext;
ACPI_STATUS Status = AE_OK;
DPRINT("acpi_os_queue_for_execution()\n");
@ -479,27 +472,20 @@ acpi_os_queue_for_execution(
DPRINT("Scheduling task [%p](%p) for execution.\n", function, context);
Dpc = ExAllocatePool(NonPagedPool, sizeof(KDPC) + sizeof(ACPI_OS_DPC));
if (!Dpc)
return AE_NO_MEMORY;
DpcContext = (PACPI_OS_DPC)((ULONG)Dpc + sizeof(KDPC));
DpcContext->Routine = function;
DpcContext->Context = context;
KeInitializeDpc(Dpc, OslDpcStub, DpcContext);
#if 0
switch (priority) {
case OSD_PRIORITY_MED:
KeSetImportanceDpc(Dpc, MediumImportance);
KeSetImportanceDpc(&AcpiDpc, MediumImportance);
case OSD_PRIORITY_LO:
KeSetImportanceDpc(Dpc, LowImportance);
KeSetImportanceDpc(&AcpiDpc, LowImportance);
case OSD_PRIORITY_HIGH:
default:
KeSetImportanceDpc(Dpc, HighImportance);
KeSetImportanceDpc(&AcpiDpc, HighImportance);
}
#endif
KeInsertQueueDpc(&AcpiDpc, (PVOID)function, (PVOID)context);
return Status;
}

221
reactos/drivers/bus/acpi/ospm/pdo.c Normal file
View file

@ -0,0 +1,221 @@
/* $Id: pdo.c,v 1.1 2001/08/23 17:32:04 chorns Exp $
*
* PROJECT: ReactOS ACPI bus driver
* FILE: acpi/ospm/pdo.c
* PURPOSE: Child device object dispatch routines
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* UPDATE HISTORY:
* 08-08-2001 CSH Created
*/
#include <acpisys.h>
#include <bm.h>
#include <bn.h>
#define NDEBUG
#include <debug.h>
/*** PRIVATE *****************************************************************/
NTSTATUS
PdoQueryId(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PPDO_DEVICE_EXTENSION DeviceExtension;
ACPI_STATUS AcpiStatus;
NTSTATUS Status;
DPRINT("Called\n");
DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
// Irp->IoStatus.Information = 0;
switch (IrpSp->Parameters.QueryId.IdType) {
case BusQueryDeviceID:
break;
case BusQueryHardwareIDs:
case BusQueryCompatibleIDs:
case BusQueryInstanceID:
case BusQueryDeviceSerialNumber:
default:
Status = STATUS_NOT_IMPLEMENTED;
}
return Status;
}
NTSTATUS
PdoSetPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PPDO_DEVICE_EXTENSION DeviceExtension;
ACPI_STATUS AcpiStatus;
NTSTATUS Status;
ULONG AcpiState;
DPRINT("Called\n");
DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
if (IrpSp->Parameters.Power.Type == DevicePowerState) {
Status = STATUS_SUCCESS;
switch (IrpSp->Parameters.Power.State.SystemState) {
default:
Status = STATUS_UNSUCCESSFUL;
}
} else {
Status = STATUS_UNSUCCESSFUL;
}
return Status;
}
/*** PUBLIC ******************************************************************/
NTSTATUS
STDCALL
PdoPnpControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
* FUNCTION: Handle Plug and Play IRPs for the child device
* ARGUMENTS:
* DeviceObject = Pointer to physical device object of the child device
* Irp = Pointer to IRP that should be handled
* RETURNS:
* Status
*/
{
PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
DPRINT("Called\n");
Status = Irp->IoStatus.Status;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
switch (IrpSp->MinorFunction) {
case IRP_MN_CANCEL_REMOVE_DEVICE:
break;
case IRP_MN_CANCEL_STOP_DEVICE:
break;
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
break;
case IRP_MN_EJECT:
break;
case IRP_MN_QUERY_BUS_INFORMATION:
break;
case IRP_MN_QUERY_CAPABILITIES:
break;
case IRP_MN_QUERY_DEVICE_RELATIONS:
/* FIXME: Possibly handle for RemovalRelations */
break;
case IRP_MN_QUERY_DEVICE_TEXT:
break;
case IRP_MN_QUERY_ID:
break;
case IRP_MN_QUERY_PNP_DEVICE_STATE:
break;
case IRP_MN_QUERY_REMOVE_DEVICE:
break;
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
break;
case IRP_MN_QUERY_RESOURCES:
break;
case IRP_MN_QUERY_STOP_DEVICE:
break;
case IRP_MN_REMOVE_DEVICE:
break;
case IRP_MN_SET_LOCK:
break;
case IRP_MN_START_DEVICE:
break;
case IRP_MN_STOP_DEVICE:
break;
case IRP_MN_SURPRISE_REMOVAL:
break;
default:
DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
break;
}
if (Status != STATUS_PENDING) {
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
DPRINT("Leaving. Status 0x%X\n", Status);
return Status;
}
NTSTATUS
STDCALL
PdoPowerControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
* FUNCTION: Handle power management IRPs for the child device
* ARGUMENTS:
* DeviceObject = Pointer to physical device object of the child device
* Irp = Pointer to IRP that should be handled
* RETURNS:
* Status
*/
{
PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
DPRINT("Called\n");
IrpSp = IoGetCurrentIrpStackLocation(Irp);
switch (IrpSp->MinorFunction) {
case IRP_MN_SET_POWER:
Status = PdoSetPower(DeviceObject, Irp, IrpSp);
break;
default:
DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
Status = STATUS_NOT_IMPLEMENTED;
break;
}
if (Status != STATUS_PENDING) {
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
DPRINT("Leaving. Status 0x%X\n", Status);
return Status;
}
/* EOF */