You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
415 lines
9.1 KiB
415 lines
9.1 KiB
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
bus.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the bus dispatcher for the ACPI driver, NT version
|
|
|
|
Author:
|
|
|
|
Stephane Plante (splante)
|
|
|
|
Environment:
|
|
|
|
NT Kernel Model Driver only
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, ACPIInternalDeviceClockIrpStartDevice)
|
|
#pragma alloc_text(PAGE, ACPIInternalDeviceQueryCapabilities)
|
|
#pragma alloc_text(PAGE, ACPIInternalDeviceQueryDeviceRelations)
|
|
#endif
|
|
|
|
|
|
NTSTATUS
|
|
ACPIInternalDeviceClockIrpStartDevice(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is called to start the Real-Time Clock in the system. This
|
|
is similar to starting all the other devices in the system, except that
|
|
in this case, we send a WAIT_WAKE irp to the device
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - The real-time clock object
|
|
Irp - The start request
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Start the device
|
|
//
|
|
status = ACPIInitStartDevice(
|
|
DeviceObject,
|
|
NULL,
|
|
ACPIInternalDeviceClockIrpStartDeviceCompletion,
|
|
Irp,
|
|
Irp
|
|
);
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
return STATUS_PENDING;
|
|
|
|
} else {
|
|
|
|
return status;
|
|
|
|
}
|
|
}
|
|
|
|
VOID
|
|
ACPIInternalDeviceClockIrpStartDeviceCompletion(
|
|
IN PDEVICE_EXTENSION DeviceExtension,
|
|
IN PVOID Context,
|
|
IN NTSTATUS Status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the callback routine that is invoked when we have finished
|
|
programming the resources
|
|
|
|
Arguments:
|
|
|
|
DeviceExtension - Extension of the device that was started
|
|
Context - The Irp
|
|
Status - The Result
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
KIRQL oldIrql;
|
|
IO_STATUS_BLOCK ioStatus;
|
|
PIRP irp = (PIRP) Context;
|
|
POWER_STATE state;
|
|
|
|
irp->IoStatus.Status = Status;
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
//
|
|
// Remember that the device is started
|
|
//
|
|
DeviceExtension->DeviceState = Started;
|
|
|
|
//
|
|
// If the device doesn't support Wakeup, then we don't have to
|
|
// anything else here
|
|
//
|
|
if ( !(DeviceExtension->Flags & DEV_CAP_WAKE) ) {
|
|
|
|
goto ACPIInternalDeviceClockIrpStartDeviceCompletionExit;
|
|
|
|
}
|
|
|
|
//
|
|
// Make sure that we are holding the power lock
|
|
//
|
|
KeAcquireSpinLock( &AcpiPowerLock, &oldIrql );
|
|
|
|
//
|
|
// Remember the maximum state that the clock can wake the system
|
|
//
|
|
state.SystemState = DeviceExtension->PowerInfo.SystemWakeLevel;
|
|
|
|
//
|
|
// Done with the lock
|
|
//
|
|
KeReleaseSpinLock( &AcpiPowerLock, oldIrql );
|
|
|
|
//
|
|
// Initialize the IO_STATUS_BLOCK that we will use to start the wait
|
|
// wake loop
|
|
//
|
|
ioStatus.Status = STATUS_SUCCESS;
|
|
ioStatus.Information = 0;
|
|
|
|
//
|
|
// Start the wait wake loop
|
|
//
|
|
Status = ACPIInternalWaitWakeLoop(
|
|
DeviceExtension->DeviceObject,
|
|
IRP_MN_WAIT_WAKE,
|
|
state,
|
|
NULL,
|
|
&ioStatus
|
|
);
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
irp->IoStatus.Status = Status;
|
|
goto ACPIInternalDeviceClockIrpStartDeviceCompletionExit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ACPIInternalDeviceClockIrpStartDeviceCompletionExit:
|
|
//
|
|
// Complete the irp
|
|
//
|
|
IoCompleteRequest( irp, IO_NO_INCREMENT );
|
|
}
|
|
|
|
NTSTATUS
|
|
ACPIInternalDeviceQueryCapabilities(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the dispatch point for the IRP_MN_QUERY_CAPABILITIES requests sent
|
|
to the PDO
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object we received the request for
|
|
Irp - Pointer to the request
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PDEVICE_CAPABILITIES capabilities;
|
|
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
|
|
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Grab a pointer to the capabilities
|
|
//
|
|
capabilities = irpStack->Parameters.DeviceCapabilities.Capabilities;
|
|
#ifndef HANDLE_BOGUS_CAPS
|
|
if (capabilities->Version < 1) {
|
|
|
|
//
|
|
// do not touch irp!
|
|
//
|
|
status = Irp->IoStatus.Status;
|
|
goto ACPIInternalDeviceQueryCapabilitiesExit;
|
|
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Set the current flags for the capabilities
|
|
//
|
|
capabilities->UniqueID = (deviceExtension->InstanceID == NULL ?
|
|
FALSE : TRUE);
|
|
|
|
capabilities->RawDeviceOK = (deviceExtension->Flags & DEV_CAP_RAW) ?
|
|
TRUE : FALSE;
|
|
|
|
capabilities->SilentInstall = TRUE;
|
|
|
|
//
|
|
// Do the power capabilities
|
|
//
|
|
status = ACPISystemPowerQueryDeviceCapabilities(
|
|
deviceExtension,
|
|
capabilities
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
|
|
ACPIDevPrint( (
|
|
ACPI_PRINT_CRITICAL,
|
|
deviceExtension,
|
|
" - Could query device capabilities - %08lx",
|
|
status
|
|
) );
|
|
goto ACPIInternalDeviceQueryCapabilitiesExit;
|
|
|
|
}
|
|
|
|
ACPIInternalDeviceQueryCapabilitiesExit:
|
|
|
|
//
|
|
// Done...
|
|
//
|
|
Irp->IoStatus.Status = status;
|
|
IoCompleteRequest( Irp, IO_NO_INCREMENT );
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ACPIInternalDeviceQueryDeviceRelations(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the dispatch point for the IRP_MN_QUERY_DEVICE_RELATION
|
|
PNP minor function
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - The object that we care about
|
|
Irp - The request in question
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status ;
|
|
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
|
|
PDEVICE_RELATIONS deviceRelations = NULL;
|
|
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
|
|
UCHAR minorFunction = irpStack->MinorFunction;
|
|
|
|
PAGED_CODE();
|
|
|
|
switch(irpStack->Parameters.QueryDeviceRelations.Type) {
|
|
|
|
case TargetDeviceRelation:
|
|
|
|
status = ACPIBusIrpQueryTargetRelation(
|
|
DeviceObject,
|
|
Irp,
|
|
&deviceRelations
|
|
);
|
|
break ;
|
|
|
|
default:
|
|
|
|
status = STATUS_NOT_SUPPORTED;
|
|
|
|
ACPIDevPrint( (
|
|
ACPI_PRINT_IRP,
|
|
deviceExtension,
|
|
"(0x%08lx): %s - Unhandled Type %d\n",
|
|
Irp,
|
|
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
|
|
irpStack->Parameters.QueryDeviceRelations.Type
|
|
) );
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// If we succeeds, then we can always write to the irp
|
|
//
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
Irp->IoStatus.Status = status;
|
|
Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
|
|
|
|
} else if (status != STATUS_NOT_SUPPORTED) {
|
|
|
|
//
|
|
// If we haven't succeed the irp, then we can also fail it
|
|
//
|
|
Irp->IoStatus.Status = status;
|
|
Irp->IoStatus.Information = (ULONG_PTR) NULL;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Grab our status from what is already present
|
|
//
|
|
status = Irp->IoStatus.Status;
|
|
|
|
}
|
|
|
|
//
|
|
// Done with the irp
|
|
//
|
|
IoCompleteRequest( Irp, IO_NO_INCREMENT );
|
|
|
|
//
|
|
// Done
|
|
//
|
|
ACPIDevPrint( (
|
|
ACPI_PRINT_IRP,
|
|
deviceExtension,
|
|
"(0x%08lx): %s = 0x%08lx\n",
|
|
Irp,
|
|
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
|
|
status
|
|
) );
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ACPIInternalWaitWakeLoop(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN UCHAR MinorFunction,
|
|
IN POWER_STATE PowerState,
|
|
IN PVOID Context,
|
|
IN PIO_STATUS_BLOCK IoStatus
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called after the WAIT_WAKE on the RTC has been completed
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - The RTC PDO
|
|
MinorFunction - IRP_MN_WAIT_WAKE
|
|
PowerState - The Sleep state that it could wake from
|
|
Context - NOT USED
|
|
IoStatus - The status of the request
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
if (!NT_SUCCESS(IoStatus->Status)) {
|
|
|
|
return IoStatus->Status;
|
|
|
|
}
|
|
|
|
//
|
|
// In this case, we just cause the same thing to happen again
|
|
//
|
|
PoRequestPowerIrp(
|
|
DeviceObject,
|
|
MinorFunction,
|
|
PowerState,
|
|
ACPIInternalWaitWakeLoop,
|
|
Context,
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Done
|
|
//
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|