mirror of https://github.com/tongzx/nt5src
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.
621 lines
13 KiB
621 lines
13 KiB
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
table.c
|
|
|
|
Abstract:
|
|
|
|
All the function related to actually loading an ACPI table
|
|
are included herein.
|
|
|
|
This, however, is mostly bookkeeping since the actual mechanics
|
|
of creating device extensions, and the name space tree are
|
|
handled elsewhere
|
|
|
|
Author:
|
|
|
|
Stephane Plante (splante)
|
|
|
|
Environment:
|
|
|
|
Kernel Mode Only
|
|
|
|
Revision History:
|
|
|
|
03/22/00 - Created (from code in callback.c)
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
|
|
NTSTATUS
|
|
ACPITableLoad(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called when the AML interpreter has finished loading
|
|
a Differentiated Data Block
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN runRootIni = FALSE;
|
|
KIRQL oldIrql;
|
|
NTSTATUS status;
|
|
PDEVICE_EXTENSION fixedButtonExtension = NULL;
|
|
PNSOBJ iniObject;
|
|
PNSOBJ nsObject;
|
|
|
|
//
|
|
// At this point, we should do everything that we need to do once the
|
|
// name space has been loaded. Note that we need to make sure that we
|
|
// only do those things once...
|
|
//
|
|
KeAcquireSpinLock( &AcpiDeviceTreeLock, &oldIrql );
|
|
|
|
//
|
|
// We need the ACPI object for the _SB tree
|
|
//
|
|
status = AMLIGetNameSpaceObject( "\\_SB", NULL, &nsObject, 0 );
|
|
if (!NT_SUCCESS(status)) {
|
|
|
|
//
|
|
// Ooops. Failure
|
|
//
|
|
ACPIPrint( (
|
|
ACPI_PRINT_CRITICAL,
|
|
"ACPICallBackLoadUnloadDDB: No SB Object!\n"
|
|
) );
|
|
ACPIInternalError( ACPI_CALLBACK );
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
//
|
|
// Make sure that the root device extension's object points to the correct
|
|
// thing. We only want to run through this code path once...
|
|
//
|
|
if (RootDeviceExtension->AcpiObject == NULL) {
|
|
|
|
runRootIni = TRUE;
|
|
InterlockedIncrement( &(RootDeviceExtension->ReferenceCount) );
|
|
RootDeviceExtension->AcpiObject = nsObject;
|
|
nsObject->Context = RootDeviceExtension;
|
|
|
|
//
|
|
// Now, enumerate the fixed button
|
|
//
|
|
status = ACPIBuildFixedButtonExtension(
|
|
RootDeviceExtension,
|
|
&fixedButtonExtension
|
|
);
|
|
if (NT_SUCCESS(status) &&
|
|
fixedButtonExtension != NULL) {
|
|
|
|
//
|
|
// Incremement the reference count on the node. We do this because
|
|
// we are going to be doing work (which will take a long time
|
|
// to complete, anyways), and we don't want to hold the lock for that
|
|
// entire time. If we incr the reference count, then we guarantee that
|
|
// no one can come along and kick the feet out from underneath us
|
|
//
|
|
InterlockedIncrement( &(fixedButtonExtension->ReferenceCount) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// We now want to run the _INI through the entire tree, starting at
|
|
// the _SB
|
|
//
|
|
status = ACPIBuildRunMethodRequest(
|
|
RootDeviceExtension,
|
|
NULL,
|
|
NULL,
|
|
PACKED_INI,
|
|
(RUN_REQUEST_CHECK_STATUS | RUN_REQUEST_RECURSIVE | RUN_REQUEST_MARK_INI),
|
|
FALSE
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
|
|
ACPIInternalError( ACPI_CALLBACK );
|
|
|
|
}
|
|
|
|
KeReleaseSpinLock( &AcpiDeviceTreeLock, oldIrql );
|
|
|
|
//
|
|
// We also need to run the _INI method off of the root name space entry
|
|
//
|
|
if (runRootIni) {
|
|
|
|
iniObject = ACPIAmliGetNamedChild( nsObject->pnsParent, PACKED_INI );
|
|
if (iniObject) {
|
|
|
|
AMLINestAsyncEvalObject(
|
|
iniObject,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// We need a synchronization point after we finish running the
|
|
// DPC engine. We want to be able to move anything in the Delayed
|
|
// Power Queue over to the Power DPC engine
|
|
//
|
|
status = ACPIBuildSynchronizationRequest(
|
|
RootDeviceExtension,
|
|
ACPITableLoadCallBack,
|
|
NULL,
|
|
&AcpiBuildDeviceList,
|
|
FALSE
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
|
|
ACPIInternalError( ACPI_CALLBACK );
|
|
|
|
}
|
|
|
|
//
|
|
// We need to hold this spinlock
|
|
//
|
|
KeAcquireSpinLock( &AcpiBuildQueueLock, &oldIrql );
|
|
|
|
//
|
|
// Do we need to run the DPC?
|
|
//
|
|
if (!AcpiBuildDpcRunning) {
|
|
|
|
KeInsertQueueDpc( &AcpiBuildDpc, 0, 0);
|
|
|
|
}
|
|
|
|
//
|
|
// Done with the lock
|
|
//
|
|
KeReleaseSpinLock( &AcpiBuildQueueLock, oldIrql );
|
|
|
|
//
|
|
// Done
|
|
//
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
ACPITableLoadCallBack(
|
|
IN PVOID BuildContext,
|
|
IN PVOID Context,
|
|
IN NTSTATUS Status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called when we have emptied all of the elements
|
|
within the AcpiBuildDeviceList. This is a good time to move items
|
|
from the AcpiPowerDelayedQueueList to the AcpiPowerQueueList.
|
|
|
|
Arguments:
|
|
|
|
BuildContext - Not used (it is the RootDeviceExtension)
|
|
Context - NULL
|
|
Status - Status of the operation
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
UNREFERENCED_PARAMETER( BuildContext );
|
|
UNREFERENCED_PARAMETER( Context );
|
|
UNREFERENCED_PARAMETER( Status );
|
|
|
|
ASSERT( KeGetCurrentIrql() == DISPATCH_LEVEL );
|
|
|
|
//
|
|
// We want to rebuilt the device based GPE mask here, so
|
|
// we need the following locks
|
|
//
|
|
KeAcquireSpinLockAtDpcLevel( &AcpiDeviceTreeLock );
|
|
KeAcquireSpinLockAtDpcLevel( &GpeTableLock );
|
|
|
|
//
|
|
// Now, we need to walk the device namespace and find which events
|
|
// are special, which are wake events, and which are run-time events
|
|
// As a matter of practical theory, its not possible for there to
|
|
// be a _PRW on the root device extension, so we should be safely
|
|
// able to walk only the Root's children and thereon
|
|
//
|
|
ACPIGpeBuildWakeMasks(RootDeviceExtension);
|
|
|
|
//
|
|
// We don't need these particular spin locks anymore
|
|
//
|
|
KeReleaseSpinLockFromDpcLevel( &GpeTableLock );
|
|
KeReleaseSpinLockFromDpcLevel( &AcpiDeviceTreeLock );
|
|
|
|
//
|
|
// We need the power lock to touch these Power Queues
|
|
//
|
|
KeAcquireSpinLockAtDpcLevel( &AcpiPowerQueueLock );
|
|
|
|
//
|
|
// If we there are items on the delayed list, we need to put them
|
|
// on the main list
|
|
//
|
|
if (!IsListEmpty( &AcpiPowerDelayedQueueList ) ) {
|
|
|
|
//
|
|
// Move the list
|
|
//
|
|
ACPIInternalMoveList(
|
|
&AcpiPowerDelayedQueueList,
|
|
&AcpiPowerQueueList
|
|
);
|
|
|
|
//
|
|
// Schedule the DPC, if necessary
|
|
///
|
|
if (!AcpiPowerDpcRunning) {
|
|
|
|
KeInsertQueueDpc( &AcpiPowerDpc, 0, 0 );
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Done with the lock
|
|
//
|
|
KeReleaseSpinLockFromDpcLevel( &AcpiPowerQueueLock );
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
EXPORT
|
|
ACPITableNotifyFreeObject(
|
|
ULONG Event,
|
|
PVOID Context,
|
|
ULONG ObjectType
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called when interpreter tells us that an
|
|
object has been freed
|
|
|
|
Arguments:
|
|
|
|
Event - the step in unload
|
|
Object - the object being unloaded
|
|
ObjectType - the type of the object
|
|
|
|
--*/
|
|
{
|
|
LONG oldReferenceCount;
|
|
PDEVICE_EXTENSION deviceExtension;
|
|
PDEVICE_EXTENSION parentExtension;
|
|
PKIRQL oldIrql;
|
|
PNSOBJ object;
|
|
|
|
//
|
|
// Start case
|
|
//
|
|
if (Event == DESTROYOBJ_START) {
|
|
|
|
ACPIPrint( (
|
|
ACPI_PRINT_CRITICAL,
|
|
"Unloading: Start\n"
|
|
) );
|
|
|
|
oldIrql = (PKIRQL) Context;
|
|
KeAcquireSpinLock( &AcpiDeviceTreeLock, oldIrql );
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
if (Event == DESTROYOBJ_END) {
|
|
|
|
ACPIPrint( (
|
|
ACPI_PRINT_CRITICAL,
|
|
"Unloading: End\n"
|
|
) );
|
|
|
|
oldIrql = (PKIRQL) Context;
|
|
KeReleaseSpinLock( &AcpiDeviceTreeLock, *oldIrql );
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// At this point, we have a either a valid unload request or
|
|
// a bugcheck request
|
|
//
|
|
object = (PNSOBJ) Context;
|
|
|
|
//
|
|
// Let the world Know...
|
|
//
|
|
ACPIPrint( (
|
|
ACPI_PRINT_CRITICAL,
|
|
"%x: Unloading: %x %x %x\n",
|
|
(object ? object->Context : 0),
|
|
object,
|
|
ObjectType,
|
|
Event
|
|
) );
|
|
|
|
//
|
|
// Handle the bugcheck cases
|
|
//
|
|
if (Event == DESTROYOBJ_CHILD_NOT_FREED) {
|
|
|
|
KeBugCheckEx(
|
|
ACPI_BIOS_ERROR,
|
|
ACPI_TABLE_UNLOAD,
|
|
(ULONG_PTR) object,
|
|
0,
|
|
0
|
|
);
|
|
|
|
}
|
|
if (Event == DESTROYOBJ_BOGUS_PARENT) {
|
|
|
|
KeBugCheckEx(
|
|
ACPI_BIOS_ERROR,
|
|
ACPI_TABLE_UNLOAD,
|
|
(ULONG_PTR) object,
|
|
1,
|
|
0
|
|
);
|
|
|
|
}
|
|
|
|
//
|
|
// We only understand processors, thermal zones, and devices for right
|
|
// now, we will have to add power resources at a later point
|
|
//
|
|
if (ObjectType == OBJTYPE_POWERRES) {
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
//
|
|
// Grab the device extension, and make sure that one exists
|
|
//
|
|
deviceExtension = object->Context;
|
|
if (deviceExtension == NULL) {
|
|
|
|
//
|
|
// No device extension, so we can free this thing *now*
|
|
//
|
|
AMLIDestroyFreedObjs( object );
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
//
|
|
// Mark the extension as no longer existing
|
|
//
|
|
ACPIInternalUpdateFlags(
|
|
&(deviceExtension->Flags),
|
|
DEV_PROP_UNLOADING,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// Does this device have a parent extension? It might not
|
|
// have an extension if the parent has been marked for removal
|
|
//
|
|
parentExtension = deviceExtension->ParentExtension;
|
|
if (parentExtension != NULL) {
|
|
|
|
//
|
|
// Mark the parent's relations as invalid
|
|
//
|
|
ACPIInternalUpdateFlags(
|
|
&(parentExtension->Flags),
|
|
DEV_PROP_INVALID_RELATIONS,
|
|
FALSE
|
|
);
|
|
|
|
}
|
|
|
|
//
|
|
// Finally, decrement the reference count on the device...
|
|
//
|
|
oldReferenceCount = InterlockedDecrement(
|
|
&(deviceExtension->ReferenceCount)
|
|
);
|
|
if (oldReferenceCount == 0) {
|
|
|
|
//
|
|
// Free this extension
|
|
//
|
|
ACPIInitDeleteDeviceExtension( deviceExtension );
|
|
|
|
}
|
|
|
|
//
|
|
// Done
|
|
//
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
ACPITableUnload(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called after a table has been unloaded.
|
|
|
|
The purpose of this routine is to go out and issue the invalidate
|
|
device relations on all elements of the table whose children are
|
|
going away...
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
KIRQL oldIrql;
|
|
PDEVICE_EXTENSION deviceExtension;
|
|
|
|
//
|
|
// We will need to hold the device tree lock for the following
|
|
//
|
|
KeAcquireSpinLock( &AcpiDeviceTreeLock, &oldIrql );
|
|
|
|
//
|
|
// Check to see if we have to invalid the root's device extension?
|
|
//
|
|
deviceExtension = RootDeviceExtension;
|
|
if (deviceExtension && !(deviceExtension->Flags & DEV_TYPE_NOT_FOUND) ) {
|
|
|
|
if (deviceExtension->Flags & DEV_PROP_INVALID_RELATIONS) {
|
|
|
|
ACPIInternalUpdateFlags(
|
|
&(deviceExtension->Flags),
|
|
DEV_PROP_INVALID_RELATIONS,
|
|
TRUE
|
|
);
|
|
IoInvalidateDeviceRelations(
|
|
deviceExtension->PhysicalDeviceObject,
|
|
BusRelations
|
|
);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Walk the namespace looking for bogus relations
|
|
//
|
|
ACPITableUnloadInvalidateRelations( deviceExtension );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Done with the lock
|
|
//
|
|
KeReleaseSpinLock( &AcpiDeviceTreeLock, oldIrql );
|
|
|
|
//
|
|
// And with the function
|
|
//
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
ACPITableUnloadInvalidateRelations(
|
|
IN PDEVICE_EXTENSION DeviceExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This recursive routine is called to walke the namespace and issue
|
|
the appropriate invalidates.
|
|
|
|
The device tree lock is owned during this call...
|
|
|
|
Arguments:
|
|
|
|
DeviceExtension - The device whose child extension we have to check
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
EXTENSIONLIST_ENUMDATA eled;
|
|
PDEVICE_EXTENSION childExtension;
|
|
|
|
//
|
|
// Setup the data structures that we will use to walk the
|
|
// device extension tree
|
|
//
|
|
ACPIExtListSetupEnum(
|
|
&eled,
|
|
&(DeviceExtension->ChildDeviceList),
|
|
NULL,
|
|
SiblingDeviceList,
|
|
WALKSCHEME_NO_PROTECTION
|
|
);
|
|
|
|
//
|
|
// Look at all the children of the current device extension
|
|
//
|
|
for (childExtension = ACPIExtListStartEnum( &eled) ;
|
|
ACPIExtListTestElement( &eled, TRUE);
|
|
childExtension = ACPIExtListEnumNext( &eled) ) {
|
|
|
|
//
|
|
// Does this object have any device objects?
|
|
//
|
|
if (!(childExtension->Flags & DEV_TYPE_NOT_FOUND) ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
//
|
|
// Do we have to invalidate this object's relations?
|
|
//
|
|
if (childExtension->Flags & DEV_PROP_INVALID_RELATIONS) {
|
|
|
|
ACPIInternalUpdateFlags(
|
|
&(childExtension->Flags),
|
|
DEV_PROP_INVALID_RELATIONS,
|
|
TRUE
|
|
);
|
|
IoInvalidateDeviceRelations(
|
|
childExtension->PhysicalDeviceObject,
|
|
BusRelations
|
|
);
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Recurse
|
|
//
|
|
ACPITableUnloadInvalidateRelations( childExtension );
|
|
|
|
} // for ( ... )
|
|
|
|
//
|
|
// Done
|
|
//
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|