windows-xp/Source/XPSP1/NT/base/busdrv/acpi/driver/nt/wake.c

/*++

Copyright (c) 1997  Microsoft Corporation

Module Name:

    wake.c

Abstract:

    Handles wake code for the entire ACPI subsystem

Author:

    splante (splante)

Environment:

    Kernel mode only.

Revision History:

    06-18-97:   Initial Revision
    11-24-97:   Rewrite

--*/

#include "pch.h"
#pragma hdrstop
#define INITGUID
#include <initguid.h>
#include <pciintrf.h>

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE,ACPIWakeEnableDisableSync)
#endif

//
// This request is used by the synchronous mechanism when it calls the
// asynchronous one
//
typedef struct _ACPI_WAKE_PSW_SYNC_CONTEXT {
    KEVENT      Event;
    NTSTATUS    Status;
} ACPI_WAKE_PSW_SYNC_CONTEXT, *PACPI_WAKE_PSW_SYNC_CONTEXT;

//
// This is a lookaside list of contexts
//
NPAGED_LOOKASIDE_LIST   PswContextLookAsideList;

//
// Pointer to the PCI PME interface, which we will need (maybe)
//
PPCI_PME_INTERFACE      PciPmeInterface;

//
// Have we loaded the PCI PME Interface?
//
BOOLEAN                 PciPmeInterfaceInstantiated;

//
// We need to access this piece of data here
//
extern PACPIInformation AcpiInformation;

VOID
ACPIWakeCompleteRequestQueue(
    IN  PLIST_ENTRY         RequestList,
    IN  NTSTATUS            Status
    )
/*++

Routine Description:

    This routine takes a LIST_ENTRY of requests to be completed and completes
    all of them. This is to minimize code duplication.

Arguments:

    RequestList - List Entry to process
    Status      - Status to complete the requests with

Return Value:

    None

--*/
{
    PLIST_ENTRY         listEntry;
    PACPI_POWER_REQUEST powerRequest;

    //
    // walk the list
    //
    listEntry = RequestList->Flink;
    while (listEntry != RequestList) {

        //
        // Crack the request
        //
        powerRequest = CONTAINING_RECORD(
            listEntry,
            ACPI_POWER_REQUEST,
            ListEntry
            );
        listEntry = listEntry->Flink;

        //
        // Complete this power request
        //
        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            powerRequest->DeviceExtension,
            "ACPIWakeCompleteRequestQueue - Completing 0x%08lx - %08lx\n",
            powerRequest,
            Status
            ) );
        powerRequest->Status = Status;
        ACPIDeviceIrpWaitWakeRequestComplete( powerRequest );

    }

}

NTSTATUS
ACPIWakeDisableAsync(
    IN  PDEVICE_EXTENSION   DeviceExtension,
    IN  PLIST_ENTRY         RequestList,
    IN  PFNACB              CallBack,
    IN  PVOID               Context
    )
/*++

Routine Description:

    This routine decrements the number of outstanding wake events on the
    supplied DeviceExtension by the number of items in the request list.
    If the reference goes to 0, then we run _PSW(Off) to disable wake support
    on the device

Arguments:

    DeviceExtension - Device for which we to deference the wake count
    RequestList     - The list of requests, for which the ref count will
                      be decreased
    CallBack        - Function to call when we are done
    Context         - Argument to the function

Return Value:

    NTSTATUS

--*/
{
    BOOLEAN                 runPsw          = FALSE;
    KIRQL                   oldIrql;
    NTSTATUS                status          = STATUS_SUCCESS;
    OBJDATA                 pswData;
    PACPI_WAKE_PSW_CONTEXT  pswContext;
    PLIST_ENTRY             listEntry       = RequestList->Flink;
    PNSOBJ                  pswObject       = NULL;
    ULONG                   count           = 0;

    //
    // Walk the list, counting the number of items within it
    //
    while (listEntry != RequestList) {

        count++;
        listEntry = listEntry->Flink;

    }

    //
    // Grab the spinlock
    //
    KeAcquireSpinLock( &AcpiPowerLock, &oldIrql );

    //
    // Let the world know what happened
    //
    ACPIDevPrint( (
        ACPI_PRINT_WAKE,
        DeviceExtension,
        "ACPIWakeDisableAsync - ReferenceCount: %lx - %lx = %lx\n",
        DeviceExtension->PowerInfo.WakeSupportCount,
        count,
        (DeviceExtension->PowerInfo.WakeSupportCount - count)
        ) );

    //
    // Update the number of references on the device
    //
    ASSERT( DeviceExtension->PowerInfo.WakeSupportCount <= count );
    DeviceExtension->PowerInfo.WakeSupportCount -= count;

    //
    // Grab the pswObject
    //
    pswObject = DeviceExtension->PowerInfo.PowerObject[PowerDeviceUnspecified];
    if (pswObject == NULL) {

        goto ACPIWakeDisableAsyncExit;

    }

    //
    // Are there no references left on the device?
    //
    if (DeviceExtension->PowerInfo.WakeSupportCount != 0) {

        //
        // If we own the PME pin for this device, then make sure that
        // we clear the status pin and keep the PME signal enabled
        //
        if (DeviceExtension->Flags & DEV_PROP_HAS_PME ) {

            ACPIWakeEnableDisablePciDevice(
                DeviceExtension,
                TRUE
                );

        }
        goto ACPIWakeDisableAsyncExit;

    }

    //
    // Allocate the _PSW context that we need to signify that there is
    // a pending _PSW on this device
    //
    pswContext = ExAllocateFromNPagedLookasideList(
        &PswContextLookAsideList
        );
    if (pswContext == NULL) {

        status = STATUS_INSUFFICIENT_RESOURCES;
        goto ACPIWakeDisableAsyncExit;

    }

    //
    // Initialize the context
    //
    pswContext->Enable = FALSE;
    pswContext->CallBack = CallBack;
    pswContext->Context = Context;
    pswContext->DeviceExtension = DeviceExtension;
    pswContext->Count = count;

    //
    // Check to see if we are simply going to queue the context up, or
    // call the interpreter
    //
    if (IsListEmpty( &(DeviceExtension->PowerInfo.WakeSupportList) ) ) {

        runPsw = TRUE;

    }

    //
    // List is non-empty, so we just queue up the context
    //
    InsertTailList(
        &(DeviceExtension->PowerInfo.WakeSupportList),
        &(pswContext->ListEntry)
        );

    //
    // Release the lock
    //
    KeReleaseSpinLock( &AcpiPowerLock, oldIrql );

    //
    // Should we run the method?
    //
    if (runPsw) {

        //
        // If we own the PCI PME pin for this device, the make sure to clear the
        // status and disable it --- we enable the PME pin after we have
        // turned on the _PSW, and we disable the PME pin before we turn off
        // the _PSW
        //
        if ( (DeviceExtension->Flags & DEV_PROP_HAS_PME)) {

            ACPIWakeEnableDisablePciDevice(
                DeviceExtension,
                FALSE
                );

        }

        //
        // Initialize the arguments
        //
        RtlZeroMemory( &pswData, sizeof(OBJDATA) );
        pswData.dwDataType = OBJTYPE_INTDATA;
        pswData.uipDataValue = 0;

        //
        // Run the control method
        //
        status = AMLIAsyncEvalObject(
            pswObject,
            NULL,
            1,
            &pswData,
            ACPIWakeEnableDisableAsyncCallBack,
            pswContext
            );

        //
        // What Happened
        //
        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            DeviceExtension,
            "ACPIWakeDisableAsync = 0x%08lx (P)\n",
            status
            ) );


        if (status != STATUS_PENDING) {

            ACPIWakeEnableDisableAsyncCallBack(
                pswObject,
                status,
                NULL,
                pswContext
                );

        }
        return STATUS_PENDING;

    } else {

        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            DeviceExtension,
            "ACPIWakeEnableDisableAsync = 0x%08lx (Q)\n",
            STATUS_PENDING
            ) );

        //
        // we queued the request up, so we must return pending
        //
        return STATUS_PENDING;

    }

ACPIWakeDisableAsyncExit:

    //
    // Release the lock
    //
    KeReleaseSpinLock( &AcpiPowerLock, oldIrql );

    //
    // What happened
    //
    ACPIDevPrint( (
        ACPI_PRINT_WAKE,
        DeviceExtension,
        "ACPIWakeDisableAsync = 0x%08lx\n",
        status
        ) );

    //
    // Call the specified callback ourselves
    //
    (*CallBack)(
        pswObject,
        status,
        NULL,
        Context
        );
    return STATUS_PENDING;


}

NTSTATUS
ACPIWakeEmptyRequestQueue(
    IN  PDEVICE_EXTENSION   DeviceExtension
    )
/*++

Routine Description:

    This routine looks at the current list of Wake Request irps and
    completes the ones that are waiting on the specified device

    Note: this code assumes that if we clear the irps out but we don't
    run _PSW(O), that nothing bad will happen if that GPE fires

Arguments:

    DeviceExtension - Device for which we want no wake requests

Return Value:

    None

--*/
{
    KIRQL               oldIrql;
    LIST_ENTRY          powerList;

    //
    // We will store the list of matching requests onto this list, so we
    // must initialize it
    //
    InitializeListHead( &powerList );

    //
    // We need to hold both the Cancel and the Power lock while we remove
    // things from the PowerQueue list
    //
    IoAcquireCancelSpinLock( &oldIrql );
    KeAcquireSpinLockAtDpcLevel( &AcpiPowerLock );
    ACPIWakeRemoveDevicesAndUpdate( DeviceExtension, &powerList );
    KeReleaseSpinLockFromDpcLevel( &AcpiPowerLock );
    IoReleaseCancelSpinLock( oldIrql );

    //
    // Complete the requests
    //
    ACPIWakeCompleteRequestQueue( &powerList, STATUS_NO_SUCH_DEVICE );

    //
    // Done
    //
    return STATUS_SUCCESS;

}

NTSTATUS
ACPIWakeEnableDisableAsync(
    IN  PDEVICE_EXTENSION   DeviceExtension,
    IN  BOOLEAN             Enable,
    IN  PFNACB              CallBack,
    IN  PVOID               Context
    )
/*++

Routine Description:

    Given a Device Extension, updates the count of outstanding PSW on the
    device. If there is a 0-1 transition, then we must run _PSW(1). If there
    is a 1-0 transition, then we must run _PSW(0)

    NB: The CallBack will always be invoked

Arguments:


    DeviceExtension - Object to look at
    Enable          - Increment or Decrement
    CallBack        - Function to run after running _PSW()
    Context         - Argument to pass to _PSW

Return Value:

    Status

--*/
{
    BOOLEAN                 runPsw      = FALSE;
    KIRQL                   oldIrql;
    OBJDATA                 pswData;
    NTSTATUS                status      = STATUS_SUCCESS;
    PACPI_WAKE_PSW_CONTEXT  pswContext;
    PNSOBJ                  pswObject   = NULL;

    //
    // Acquire the Spinlock
    //
    KeAcquireSpinLock( &AcpiPowerLock, &oldIrql );

    //
    // Update the number of references on the device
    //
    if (Enable) {

        DeviceExtension->PowerInfo.WakeSupportCount++;

        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            DeviceExtension,
            "ACPIWakeEnableDisableAsync - Count: %d (+)\n",
            DeviceExtension->PowerInfo.WakeSupportCount
            ) );

        //
        // Did we transition to one wake?
        //
        if (DeviceExtension->PowerInfo.WakeSupportCount != 1) {

            //
            // If we own the PME pin for this device, then make sure that
            // we clear the status pin and keep the PME signal enabled
            //
            if (DeviceExtension->Flags & DEV_PROP_HAS_PME ) {

                ACPIWakeEnableDisablePciDevice(
                    DeviceExtension,
                    TRUE
                    );

            }
            goto ACPIWakeEnableDisableAsyncExit;

        }

    } else {

        ASSERT( DeviceExtension->PowerInfo.WakeSupportCount );
        DeviceExtension->PowerInfo.WakeSupportCount--;

        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            DeviceExtension,
            "ACPIWakeEnableDisableAsync - Count: %d (-)\n",
            DeviceExtension->PowerInfo.WakeSupportCount
            ) );

        //
        // Did we transition to zero wake?
        //
        if (DeviceExtension->PowerInfo.WakeSupportCount != 0) {

            //
            // If we own the PME pin for this device, then make sure that
            // we clear the status pin and keep the PME signal enabled
            //
            if (DeviceExtension->Flags & DEV_PROP_HAS_PME ) {

                ACPIWakeEnableDisablePciDevice(
                    DeviceExtension,
                    TRUE
                    );

            }
            goto ACPIWakeEnableDisableAsyncExit;

        }

    }

    //
    // Grab the pswObject
    //
    pswObject = DeviceExtension->PowerInfo.PowerObject[PowerDeviceUnspecified];
    if (pswObject == NULL) {

        //
        // If we got here, that means that there isn't a _PSW to be run and
        // that we should make sure that if we own the PME pin, that we should
        // set it.
        //
        if (DeviceExtension->Flags & DEV_PROP_HAS_PME) {

            ACPIWakeEnableDisablePciDevice(
                DeviceExtension,
                TRUE
                );

        }
        goto ACPIWakeEnableDisableAsyncExit;

    }

    //
    // Allocate the _PSW context that we need to signify that there is
    // a pending _PSW on this device
    //
    pswContext = ExAllocateFromNPagedLookasideList(
        &PswContextLookAsideList
        );
    if (pswContext == NULL) {

        status = STATUS_INSUFFICIENT_RESOURCES;
        goto ACPIWakeEnableDisableAsyncExit;

    }

    //
    // Initialize the context
    //
    pswContext->Enable = Enable;
    pswContext->CallBack = CallBack;
    pswContext->Context = Context;
    pswContext->DeviceExtension = DeviceExtension;
    pswContext->Count = 1;

    //
    // Check to see if we are simply going to queue the context up, or
    // call the interpreter
    //
    if (IsListEmpty( &(DeviceExtension->PowerInfo.WakeSupportList) ) ) {

        runPsw = TRUE;

    }

    //
    // List is non-empty, so we just queue up the context
    //
    InsertTailList(
        &(DeviceExtension->PowerInfo.WakeSupportList),
        &(pswContext->ListEntry)
        );

    //
    // Release the lock
    //
    KeReleaseSpinLock( &AcpiPowerLock, oldIrql );

    //
    // Should we run the method?
    //
    if (runPsw) {

        //
        // If we own the PCI PME pin for this device, the make sure to clear the
        // status and disable it --- we enable the PME pin after we have
        // turned on the _PSW, and we disable the PME pin before we turn off
        // the _PSW
        //
        if ( (DeviceExtension->Flags & DEV_PROP_HAS_PME) &&
             pswContext->Enable == FALSE) {

            ACPIWakeEnableDisablePciDevice(
                DeviceExtension,
                FALSE
                );

        }

        //
        // Initialize the arguments
        //
        RtlZeroMemory( &pswData, sizeof(OBJDATA) );
        pswData.dwDataType = OBJTYPE_INTDATA;
        pswData.uipDataValue = (Enable ? 1 : 0);

        //
        // Run the control method
        //
        status = AMLIAsyncEvalObject(
            pswObject,
            NULL,
            1,
            &pswData,
            ACPIWakeEnableDisableAsyncCallBack,
            pswContext
            );

        //
        // What Happened
        //
        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            DeviceExtension,
            "ACPIWakeEnableDisableAsync = 0x%08lx (P)\n",
            status
            ) );

        if (status != STATUS_PENDING) {

            ACPIWakeEnableDisableAsyncCallBack(
                pswObject,
                status,
                NULL,
                pswContext
                );

        }
        return STATUS_PENDING;

    } else {

        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            DeviceExtension,
            "ACPIWakeEnableDisableAsync = 0x%08lx (Q)\n",
            STATUS_PENDING
            ) );

        //
        // we queued the request up, so we must return pending
        //
        return STATUS_PENDING;

    }

ACPIWakeEnableDisableAsyncExit:

    //
    // Release the lock
    //
    KeReleaseSpinLock( &AcpiPowerLock, oldIrql );

    //
    // What happened
    //
    ACPIDevPrint( (
        ACPI_PRINT_WAKE,
        DeviceExtension,
        "ACPIWakeEnableDisableAsync = 0x%08lx\n",
        status
        ) );

    //
    // Call the specified callback ourselves
    //
    (*CallBack)(
        pswObject,
        status,
        NULL,
        Context
        );
    return STATUS_PENDING;

}

VOID
EXPORT
ACPIWakeEnableDisableAsyncCallBack(
    IN  PNSOBJ      AcpiObject,
    IN  NTSTATUS    Status,
    IN  POBJDATA    ObjData,
    IN  PVOID       Context
    )
/*++

Routine Description:

    This routine is called after a _PSW method has been run on a device.

    This routine is responsible for seeing if there are any more delayed
    _PSW requests on the same device, and if so, run them.

Arguments:

    AcpiObject  - The method object that was run
    Status      - The result of the eval
    ObjData     - Not used
    Context     - PACPI_WAKE_PSW_CONTEXT

Return value:

    VOID

--*/
{
    BOOLEAN                 runPsw          = FALSE;
    KIRQL                   oldIrql;
    PACPI_WAKE_PSW_CONTEXT  pswContext      = (PACPI_WAKE_PSW_CONTEXT) Context;
    PACPI_WAKE_PSW_CONTEXT  nextContext;
    PDEVICE_EXTENSION       deviceExtension = pswContext->DeviceExtension;

    ACPIDevPrint( (
        ACPI_PRINT_WAKE,
        deviceExtension,
        "ACPIWakeEnableDisableAsyncCallBack = %08lx (C)\n",
        Status
        ) );

    //
    // Acquire the spinlock
    //
    KeAcquireSpinLock( &AcpiPowerLock, &oldIrql );

    //
    // Remove the specified entry from the list
    //
    RemoveEntryList( &(pswContext->ListEntry) );

    //
    // If we failed the request, then we don't really know the status of the
    // _PSW on the device. Lets assume that it doesn't change and undo
    // whatever change we did to get here
    //
    if (!NT_SUCCESS(Status)) {

        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            deviceExtension,
            "ACPIWakeEnableDisableAsyncCallBack - RefCount: %lx %s %lx = %lx\n",
            deviceExtension->PowerInfo.WakeSupportCount,
            (pswContext->Enable ? "-" : "+"),
            pswContext->Count,
            (pswContext->Enable ? deviceExtension->PowerInfo.WakeSupportCount -
             pswContext->Count : deviceExtension->PowerInfo.WakeSupportCount +
             pswContext->Count)
            ) );


        if (pswContext->Enable) {

            deviceExtension->PowerInfo.WakeSupportCount -= pswContext->Count;

        } else {

            deviceExtension->PowerInfo.WakeSupportCount += pswContext->Count;

        }

    }

    //
    // If we own the PCI PME pin for this device, the make sure to clear the
    // status and either enable it --- we enable the PME pin after we have
    // turned on the _PSW, and we disable the PME pin before we turn off
    // the _PSW
    //
    if ( (deviceExtension->Flags & DEV_PROP_HAS_PME) &&
         pswContext->Enable == TRUE) {

        ACPIWakeEnableDisablePciDevice(
            deviceExtension,
            pswContext->Enable
            );

    }

    //
    // Are the any items on the list?
    //
    if (!IsListEmpty( &(deviceExtension->PowerInfo.WakeSupportList) ) ) {

        runPsw = TRUE;
        nextContext = CONTAINING_RECORD(
            deviceExtension->PowerInfo.WakeSupportList.Flink,
            ACPI_WAKE_PSW_CONTEXT,
            ListEntry
            );

    }

    //
    // We can release the lock now
    //
    KeReleaseSpinLock( &AcpiPowerLock, oldIrql );

    //
    // Call the callback on the completed item
    //
    (*pswContext->CallBack)(
        AcpiObject,
        Status,
        ObjData,
        (pswContext->Context)
        );

    //
    // Free the completed context
    //
    ExFreeToNPagedLookasideList(
        &PswContextLookAsideList,
        pswContext
        );

    //
    // Do we have to run a method?
    //
    if (runPsw) {

        NTSTATUS    status;
        OBJDATA     pswData;

        RtlZeroMemory( &pswData, sizeof(OBJDATA) );
        pswData.dwDataType = OBJTYPE_INTDATA;
        pswData.uipDataValue = (nextContext->Enable ? 1 : 0);

        //
        // If we own the PCI PME pin for this device, the make sure to clear the
        // status and disable it --- we enable the PME pin after we have
        // turned on the _PSW, and we disable the PME pin before we turn off
        // the _PSW
        //
        if ( (deviceExtension->Flags & DEV_PROP_HAS_PME) &&
             nextContext->Enable == FALSE) {

            ACPIWakeEnableDisablePciDevice(
                deviceExtension,
                FALSE
                );

        }

        //
        // Call the interpreter
        //
        status = AMLIAsyncEvalObject(
            AcpiObject,
            NULL,
            1,
            &pswData,
            ACPIWakeEnableDisableAsyncCallBack,
            nextContext
            );

        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            nextContext->DeviceExtension,
            "ACPIWakeEnableDisableAsyncCallBack = 0x%08lx (M)\n",
            status
            ) );

        if (status != STATUS_PENDING) {

            //
            // Ugh - Recursive
            //
            ACPIWakeEnableDisableAsyncCallBack(
                AcpiObject,
                status,
                NULL,
                nextContext
                );

        }

    }

}

VOID
ACPIWakeEnableDisablePciDevice(
    IN  PDEVICE_EXTENSION   DeviceExtension,
    IN  BOOLEAN             Enable
    )
/*++

Routine Description:

    This routine is what is actually called to enable or disable the
    PCI PME pin for a device

    N.B. The AcpiPowerLock must be owned

Arguments:

    DeviceExtension - The device extension that is a filter on top of the
                      pdo from the PCI device
    Enable          - True to enable PME, false otherwise

Return Value:

    None

--*/
{
    KIRQL   oldIrql;


    //
    // Is there an interface present?
    //
    if (!PciPmeInterfaceInstantiated) {

        return;

    }

    //
    // Prevent the device from going away while we make this call
    //
    KeAcquireSpinLock( &AcpiDeviceTreeLock, &oldIrql );

    //
    // Check to see if there is a device object...
    //
    if (!DeviceExtension->PhysicalDeviceObject) {

        KeReleaseSpinLock( &AcpiDeviceTreeLock, oldIrql );
        return;

    }

    PciPmeInterface->UpdateEnable(
        DeviceExtension->PhysicalDeviceObject,
        Enable
        );

    //
    // Done with the lock
    //
    KeReleaseSpinLock( &AcpiDeviceTreeLock, oldIrql );
}

NTSTATUS
ACPIWakeEnableDisableSync(
    IN  PDEVICE_EXTENSION   DeviceExtension,
    IN  BOOLEAN             Enable
    )
/*++

Routine Description:

    Given a DeviceExtension, enables or disables the device wake support
    from the device

    NB: This routine can only be called at passive level

Arguments:

    DeviceExtension - The device we care about
    Enable          - True if we are to enable, false otherwise

Return Value:

    NTSTATUS

--*/
{
    ACPI_WAKE_PSW_SYNC_CONTEXT  syncContext;
    NTSTATUS                    status;

    PAGED_CODE();

    ASSERT( DeviceExtension != NULL &&
            DeviceExtension->Signature == ACPI_SIGNATURE );

    //
    // Initialize the event
    //
    KeInitializeEvent( &syncContext.Event, NotificationEvent, FALSE );

    //
    // Call the async procedure
    //
    status = ACPIWakeEnableDisableAsync(
        DeviceExtension,
        Enable,
        ACPIWakeEnableDisableSyncCallBack,
        &syncContext
        );
    if (status == STATUS_PENDING) {

        KeWaitForSingleObject(
            &syncContext.Event,
            Executive,
            KernelMode,
            FALSE,
            NULL
            );
        status = syncContext.Status;

    }

    //
    // Done
    //
    return status;
}

VOID
EXPORT
ACPIWakeEnableDisableSyncCallBack(
    IN  PNSOBJ      AcpiObject,
    IN  NTSTATUS    Status,
    IN  POBJDATA    ObjData,
    IN  PVOID       Context
    )
/*++

Routine Description:

    The Async part of the EnableDisable request has been completed

Arguments:

    AcpiObject  - The object that was executed
    Status      - The result of the operation
    ObjData     - Not used
    Context     - ACPI_WAKE_PSW_SYNC_CONTEXT

Return Value:

    VOID

--*/
{
    PACPI_WAKE_PSW_SYNC_CONTEXT pswContext = (PACPI_WAKE_PSW_SYNC_CONTEXT) Context;

    //
    // Set the real status
    //
    pswContext->Status = Status;

    //
    // Set the event
    //
    KeSetEvent( &(pswContext->Event), IO_NO_INCREMENT, FALSE );
}

VOID
ACPIWakeEnableWakeEvents(
    VOID
    )
/*++

Routine Description:

    This routine is called just before the system is put to sleep.

    The purpose of this routine is re-allow all wake and run-time events
    in the GpeCurEnable to be correctly set. After the machine wakes up,
    the machine will check that register to see if any events triggered the
    wakeup

    NB: This routine is called with interrupts off.

Arguments:

    None

Return Value:

    None

--*/
{
    KIRQL   oldIrql;
    ULONG   gpeRegister = 0;

    //
    // This function is called when interrupts are disabled, so in theory,
    // all the following should be safe. However, better safe than sorry.
    //
    KeAcquireSpinLock( &GpeTableLock, &oldIrql );

    //
    // Remember that on the way back up, we will entering the S0 state
    //
    AcpiPowerLeavingS0 = FALSE;

    //
    // Update all the registers
    //
    for (gpeRegister = 0; gpeRegister < AcpiInformation->GpeSize; gpeRegister++) {

        //
        // In any case, make sure that our current enable mask includes all
        // the wake registers, but doesn't include any of the pending
        // events
        //
        GpeCurEnable[gpeRegister] |= (GpeWakeEnable[gpeRegister] &
            ~GpePending[gpeRegister]);

    }

    //
    // Set the wake events only
    //
    ACPIGpeEnableWakeEvents();

    //
    // Done with the table lock
    //
    KeReleaseSpinLock( &GpeTableLock, oldIrql );
}

NTSTATUS
ACPIWakeInitializePciDevice(
    IN  PDEVICE_OBJECT      DeviceObject
    )
/*++

Routine Description:

    This routine is called when a filter is started to determine if the PCI
    device is capable of generating a PME

Arguments:

    DeviceObject    - The device object to initialize

Return Value:

    NTSTATUS

--*/
{
    BOOLEAN             pmeSupported;
    BOOLEAN             pmeStatus;
    BOOLEAN             pmeEnable;
    KIRQL               oldIrql;
    PDEVICE_EXTENSION   deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);

    //
    // We don't have to worry if the device doesn't support wake methods
    // directly
    //
    if (!(deviceExtension->Flags & DEV_CAP_WAKE) ) {

        return STATUS_SUCCESS;

    }

    //
    // Need to grab the power lock to do the following
    //
    KeAcquireSpinLock( &AcpiPowerLock, &oldIrql );

    //
    // Do we have an interface to call?
    //
    if (PciPmeInterfaceInstantiated == FALSE) {

        goto ACPIWakeInitializePciDeviceExit;

    }

    //
    // Get the status of PME for this device
    //
    PciPmeInterface->GetPmeInformation(
        deviceExtension->PhysicalDeviceObject,
        &pmeSupported,
        &pmeStatus,
        &pmeEnable
        );

    //
    // if the device supports pme, then we own it...
    //
    if (pmeSupported == TRUE) {

        //
        // We own the PME pin for this device
        //
        ACPIInternalUpdateFlags(
            &(deviceExtension->Flags),
            (DEV_PROP_HAS_PME),
            FALSE
            );

        //
        // Check to see if we should disable PME or disable the PME status
        //
        if (pmeEnable) {

            //
            // Calling this also clears the PME status pin
            //
            PciPmeInterface->UpdateEnable(
                deviceExtension->PhysicalDeviceObject,
                FALSE
                );

        } else if (pmeStatus) {

            //
            // Clear the PME status
            //
            PciPmeInterface->ClearPmeStatus(
                deviceExtension->PhysicalDeviceObject
                );

        }

    }

ACPIWakeInitializePciDeviceExit:
    //
    // Done with lock
    //
    KeReleaseSpinLock( &AcpiPowerLock, oldIrql );

    //
    // Done
    //
    return STATUS_SUCCESS;
}

NTSTATUS
ACPIWakeInitializePmeRouting(
    IN  PDEVICE_OBJECT      DeviceObject
    )
/*++

Routine Description:

    This routine will ask the PCI driver for its PME interface

Arguments:

    DeviceObject    - The ACPI PDO for a PCI root bus

Return Value:

    NTSTATUS

--*/
{
    KIRQL               oldIrql;
    NTSTATUS            status;
    IO_STACK_LOCATION   irpSp;
    PPCI_PME_INTERFACE  interface;
    PULONG              dummy;

    //
    // Allocate some memory for the interface
    //
    interface = ExAllocatePoolWithTag(
        NonPagedPool,
        sizeof(PCI_PME_INTERFACE),
        ACPI_ARBITER_POOLTAG
        );
    if (interface == NULL) {

        return STATUS_INSUFFICIENT_RESOURCES;

    }

    //
    // Initialize the stack location
    //
    RtlZeroMemory( &irpSp, sizeof(IO_STACK_LOCATION) );
    irpSp.MajorFunction = IRP_MJ_PNP;
    irpSp.MinorFunction = IRP_MN_QUERY_INTERFACE;
    irpSp.Parameters.QueryInterface.InterfaceType = (LPGUID) &GUID_PCI_PME_INTERFACE;
    irpSp.Parameters.QueryInterface.Version = PCI_PME_INTRF_STANDARD_VER;
    irpSp.Parameters.QueryInterface.Size = sizeof (PCI_PME_INTERFACE);
    irpSp.Parameters.QueryInterface.Interface = (PINTERFACE) interface;
    irpSp.Parameters.QueryInterface.InterfaceSpecificData = NULL;

    //
    // Send the request along
    //
    status = ACPIInternalSendSynchronousIrp(
        DeviceObject,
        &irpSp,
        &dummy
        );
    if (!NT_SUCCESS(status)) {

        PDEVICE_EXTENSION   deviceExtension = ACPIInternalGetDeviceExtension( DeviceObject );

        ACPIDevPrint( (
            ACPI_PRINT_CRITICAL,
            deviceExtension,
            " - ACPIWakeInitializePmeRouting = %08lx\n",
            status
            ) );

        //
        // Free the memory and return
        //
        ExFreePool( interface );
        return status;

    }

    //
    // Do this under spinlock protection
    //
    KeAcquireSpinLock( &AcpiPowerLock, &oldIrql );
    if (PciPmeInterfaceInstantiated == FALSE) {

        //
        // Keep a global pointer to the interface
        //
        PciPmeInterfaceInstantiated = TRUE;
        PciPmeInterface = interface;

    } else {

        //
        // Someone else got here before us, so we need to make sure
        // that we free the extra memory
        //
        ExFreePool (interface );

    }
    KeReleaseSpinLock( &AcpiPowerLock, oldIrql );

    //
    // Done
    //
    return status;
}

VOID
ACPIWakeRemoveDevicesAndUpdate(
    IN  PDEVICE_EXTENSION   TargetExtension,
    OUT PLIST_ENTRY         ListHead
    )
/*++

Routine Description:

    This routine finds the all of the WaitWake requests associated with
    TargetDevice and return them on ListHead. This is done in a 'safe' way

    NB: Caller must hold the AcpiPowerLock and Cancel Lock!

Arguments:

    TargetExtension - The target extension that we are looking for
    ListHead        - Where to store the list of matched devices

Return Value:

    NONE

--*/
{
    PACPI_POWER_REQUEST powerRequest;
    PDEVICE_EXTENSION   deviceExtension;
    PLIST_ENTRY         listEntry;
    SYSTEM_POWER_STATE  sleepState;
    ULONG               gpeRegister;
    ULONG               gpeMask;
    ULONG               byteIndex;

    ASSERT( KeGetCurrentIrql() == DISPATCH_LEVEL );

    //
    // We need to synchronize with the ProcessGPE code because we are going
    // to touch one of the GPE Masks
    //
    KeAcquireSpinLockAtDpcLevel( &GpeTableLock );

    //
    // The first step is to disable all the wake vectors
    //
    for (gpeRegister = 0; gpeRegister < AcpiInformation->GpeSize; gpeRegister++) {

        //
        // Remove the wake vectors from the real-time vectors.
        // Note that since we are going to be writting the GPE Enable vector
        // later on in the process, it seems pointless to actually write them
        // now as well
        //
        GpeCurEnable[gpeRegister] &= (GpeSpecialHandler[gpeRegister] |
            ~(GpeWakeEnable[gpeRegister] | GpeWakeHandler[gpeRegister]));

    }

    //
    // Next step is to reset the wake mask
    //
    RtlZeroMemory( GpeWakeEnable, AcpiInformation->GpeSize * sizeof(UCHAR) );


    //
    // Look at the first element in the wake list
    //
    listEntry = AcpiPowerWaitWakeList.Flink;

    //
    // Loop for all elements in the list
    //
    while (listEntry != &AcpiPowerWaitWakeList) {

        //
        // Grab the irp from the listEntry
        //
        powerRequest = CONTAINING_RECORD(
            listEntry,
            ACPI_POWER_REQUEST,
            ListEntry
            );

        //
        // Point to the next request
        //
        listEntry = listEntry->Flink;

        //
        // Obtain the device extension for the request
        //
        deviceExtension = powerRequest->DeviceExtension;

        //
        // If this device is to be removed, then remove it
        //
        if (deviceExtension == TargetExtension) {

            //
            // Remove the request from the list and move it to the next
            // list. Mark the irp as no longer cancelable.
            //
            IoSetCancelRoutine( (PIRP) powerRequest->Context, NULL );
            RemoveEntryList( &powerRequest->ListEntry );
            InsertTailList( ListHead, &powerRequest->ListEntry );

        } else {

            //
            // If the wake level of the bit indicates that it isn't supported
            // in the current sleep state, then don't enable it... Note that
            // this doesn't solve the problem where two devices share the
            // same vector, one can wake the computer from S2, one from S3 and
            // we are going to S3. In this case, we don't have the smarts to
            // un-run the _PSW from the S2 device
            //
            sleepState = powerRequest->u.WaitWakeRequest.SystemPowerState;
            if (sleepState < AcpiMostRecentSleepState) {

                continue;

            }

            //
            // Get the byteIndex for this GPE
            //
            byteIndex = ACPIGpeIndexToByteIndex(
                deviceExtension->PowerInfo.WakeBit
                );

            //
            // Drivers cannot register on wake vectors
            //
            if (GpeMap[byteIndex]) {

                ACPIDevPrint( (
                    ACPI_PRINT_WAKE,
                    deviceExtension,
                    "ACPIWakeRemoveDeviceAndUpdate - %x cannot be used as a"
                    "wake pin.\n",
                    deviceExtension->PowerInfo.WakeBit
                    ) );
                continue;

            }

            //
            // Calculate the entry and offset. Assume that the Parameter is
            // at most a UCHAR
            //
            gpeRegister = ACPIGpeIndexToGpeRegister(
                deviceExtension->PowerInfo.WakeBit
                );
            gpeMask  = 1 << ( (UCHAR) deviceExtension->PowerInfo.WakeBit % 8);

            //
            // This GPE is being used as a wake event
            //
            if (!(GpeWakeEnable[gpeRegister] & gpeMask)) {

                //
                // This is a wake pin
                //
                GpeWakeEnable[gpeRegister] |= gpeMask;

                //
                // Prevent machine stupity and try to clear the Status bit
                //
                ACPIWriteGpeStatusRegister( gpeRegister, (UCHAR) gpeMask );

                //
                // Do we have a control method associated with this GPE?
                //
                if (!(GpeEnable[gpeRegister] & gpeMask)) {

                    //
                    // Is this GPE already enabled?
                    //
                    if (GpeCurEnable[gpeRegister] & gpeMask) {

                        continue;

                    }

                    //
                    // Not enabled -- then there is no control method for this
                    // GPE, consider this to be a level vector.
                    //
                    GpeIsLevel[gpeRegister] |= gpeMask;
                    GpeCurEnable[gpeRegister] |= gpeMask;

                } else if (!(GpeSpecialHandler[gpeRegister] & gpeMask) ) {

                    //
                    // In this case, the GPE *does* have a control method
                    // associated with it. Remember that.
                    //
                    GpeWakeHandler[gpeRegister] |= gpeMask;

                }

            }

        }

    }

    //
    // Update all the registers
    //
    for (gpeRegister = 0; gpeRegister < AcpiInformation->GpeSize; gpeRegister++) {

        if (AcpiPowerLeavingS0) {

            //
            // If we are leaving S0, then make sure to remove *all* the
            // wake events that we know about from the current enable mask.
            // If any wake events are currently pending, that will cause us
            // to continue processing them, but hopefully will not lead us
            // to renable them
            //
            GpeCurEnable[gpeRegister] &= ~GpeWakeEnable[gpeRegister];

        } else {

            //
            // If we are re-entering S0, then we need to renable all the wake
            // events, except the ones that we are already processing
            //
            GpeCurEnable[gpeRegister] |= (GpeWakeEnable[gpeRegister] &
                ~GpePending[gpeRegister]);

        }

        //
        // Now that we have calculate what the proper register should be,
        // write it back to the hardware
        //
        ACPIWriteGpeEnableRegister( gpeRegister, GpeCurEnable[gpeRegister] );

    }

    //
    // Done with the spinlock
    //
    KeReleaseSpinLockFromDpcLevel( &GpeTableLock );

    //
    // Done
    //
    return;
}

NTSTATUS
ACPIWakeRestoreEnables(
    IN  PACPI_BUILD_CALLBACK    CallBack,
    IN  PVOID                   CallBackContext
    )
/*++

Routine Description:

    This routine re-runs through the list of WAIT-WAKE irps and runs the _PSW
    method for each of those irps again. The reason that this is done is to
    restore the state of the hardware to what the OS thinks the state is.

Arguments:

    CallBack        - The function to call when done
    CallBackContext - The context to pass to that function

Return Value:

    NTSTATUS

--*/
{
    NTSTATUS                        status;

    ASSERT( KeGetCurrentIrql() == DISPATCH_LEVEL);

    //
    // We need to hold the device tree lock
    //
    KeAcquireSpinLockAtDpcLevel( &AcpiDeviceTreeLock );

    //
    // Call the build routines that we have already tested and running to
    // cause them to walk the device extension tree and run the appropriate
    // control methods
    //
    status = ACPIBuildRunMethodRequest(
        RootDeviceExtension,
        CallBack,
        CallBackContext,
        PACKED_PSW,
        (RUN_REQUEST_CHECK_STATUS | RUN_REQUEST_RECURSIVE |
         RUN_REQUEST_CHECK_WAKE_COUNT),
        TRUE
        );

    //
    // Done with the device tree lock
    //
    KeReleaseSpinLockFromDpcLevel( &AcpiDeviceTreeLock );

    //
    // Done
    //
    return status;
}

VOID
ACPIWakeRestoreEnablesCompletion(
    IN  PDEVICE_EXTENSION   DeviceExtension,
    IN  PVOID               Context,
    IN  NTSTATUS            Status
    )
/*++

Routine Description:

    This routine is called after we have finished running all the _PSWs in the
    system

Arguments:

    DeviceExtension - The device that just completed the enables
    Context         - PACPI_POWER_REQUEST
    Status          - What the status of the operation was

--*/
{
    UNREFERENCED_PARAMETER( DeviceExtension);

    //
    // Restart the device power management engine
    //
    ACPIDeviceCompleteGenericPhase(
        NULL,
        Status,
        NULL,
        Context
        );
}

NTSTATUS
ACPIWakeWaitIrp(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp
    )
/*++

Routine Description:

    This is the routine that is called when the system wants to be notified
    of this device waking the system.

Arguments:

    DeviceObject    - The device object which is supposed to wake the system
    Irp             - The request

Return Value:

    NTSTATUS

--*/
{
    NTSTATUS                status;
    PDEVICE_EXTENSION       deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
    PIO_STACK_LOCATION      irpStack;

    //
    // The first step is to decide if this object can actually support
    // a wake.
    //
    if ( !(deviceExtension->Flags & DEV_CAP_WAKE) ) {

        //
        // We do not support wake
        //
        return ACPIDispatchForwardOrFailPowerIrp( DeviceObject, Irp );

    }

    //
    // Get the stack parameters
    //
    irpStack = IoGetCurrentIrpStackLocation( Irp );

    //
    // We must make sure that we are at the correct system level
    // to support this functionality
    //
    if (deviceExtension->PowerInfo.SystemWakeLevel <
        irpStack->Parameters.WaitWake.PowerState) {

        //
        // The system level is not the one we are currently at
        //
        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            deviceExtension,
            "(0x%08lx): ACPIWakeWaitIrp ->S%d < Irp->S%d\n",
            Irp,
            deviceExtension->PowerInfo.SystemWakeLevel - 1,
            irpStack->Parameters.WaitWake.PowerState - 1
            ) );

        //
        // Fail the Irp
        //
        Irp->IoStatus.Status = status = STATUS_INVALID_DEVICE_STATE;
        PoStartNextPowerIrp( Irp );
        IoCompleteRequest( Irp, IO_NO_INCREMENT );
        return status;

    }

    //
    // We must make sure that the device is in the proper device level
    // to support this functionality
    //
    if (deviceExtension->PowerInfo.DeviceWakeLevel <
        deviceExtension->PowerInfo.PowerState) {

        //
        // We are too much powered off to wake the computer
        //
        ACPIDevPrint( (
            ACPI_PRINT_WAKE,
            deviceExtension,
            "(0x%08lx): ACPIWakeWaitIrp  Device->D%d Max->D%d\n",
            Irp,
            deviceExtension->PowerInfo.DeviceWakeLevel - 1,
            deviceExtension->PowerInfo.PowerState - 1
            ) );

        //
        // Fail the irp
        //
        Irp->IoStatus.Status = status = STATUS_INVALID_DEVICE_STATE;
        PoStartNextPowerIrp( Irp );
        IoCompleteRequest( Irp, IO_NO_INCREMENT );
        return status;

    }

    //
    // At this point, we are definately going to run the completion routine
    // so, we mark the irp as pending and increment the reference count
    //
    IoMarkIrpPending( Irp );
    InterlockedIncrement( &deviceExtension->OutstandingIrpCount );

    //
    // Feed the request to the device power management subsystem. Note that
    // this function is supposed to invoke the completion request no matter
    // what happens.
    //
    status = ACPIDeviceIrpWaitWakeRequest(
        DeviceObject,
        Irp,
        ACPIDeviceIrpCompleteRequest
        );
    if (status == STATUS_MORE_PROCESSING_REQUIRED) {

        status = STATUS_PENDING;

    } else {

        //
        // Remove our reference
        //
        ACPIInternalDecrementIrpReferenceCount( deviceExtension );

    }
    return status;
}