windows-server-2003/net/ndis/sys/ndispwr.c

/*++

Copyright (c) 1990-1995  Microsoft Corporation

Module Name:

    ndispwr.c

Abstract:

    This module contains the code to process power managment IRPs that are
    sent under the IRP_MJ_POWER major code.

Author:

    Kyle Brandon    (KyleB)
    Alireza Dabagh  (alid)

Environment:

    Kernel mode

Revision History:

    02/11/97    KyleB           Created

--*/

#include <precomp.h>
#pragma hdrstop

#define MODULE_NUMBER   MODULE_POWER


NTSTATUS
FASTCALL
ndisQueryPowerCapabilities(
    IN  PNDIS_MINIPORT_BLOCK    Miniport
    )
/*++

Routine Description:

    This routine will process the IRP_MN_QUERY_CAPABILITIES by querying the
    next device object and saving information from that request.

Arguments:

    pIrp        -   Pointer to the IRP.
    pIrpSp      -   Pointer to the stack parameters for the IRP.
    pAdapter        -   Pointer to the device.

Return Value:

--*/
{
    PIRP                            pirp;
    PIO_STACK_LOCATION              pirpSpN;
    NTSTATUS                        Status = STATUS_SUCCESS;
    PDEVICE_CAPABILITIES            pDeviceCaps;
    DEVICE_CAPABILITIES             deviceCaps;
    POWER_QUERY                     pQuery;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisQueryPowerCapabilities: Miniport %p\n", Miniport));

    do
    {
        //
        // default = no PM support
        //
        MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_PM_SUPPORTED);

        //
        // if the Next device object is NULL, Don't bother, just flag the Miniport
        // as not supporting PM.
        // this can happen for IM devices under Memphis
        //
        if (Miniport->NextDeviceObject == NULL)
        {
            break;
        }
        
        //
        //  Send the IRP_MN_QUERY_CAPABILITIES to pdo.
        //
        pirp = IoAllocateIrp((CCHAR)(Miniport->NextDeviceObject->StackSize + 1),
                             FALSE);
        if (NULL == pirp)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisQueryPowerCapabilities: Miniport %p, Failed to allocate an irp for IRP_MN_QUERY_CAPABILITIES\n", Miniport));

            NdisWriteErrorLogEntry((NDIS_HANDLE)Miniport,
                                   NDIS_ERROR_CODE_OUT_OF_RESOURCES,
                                   0);
                                   
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
        
        NdisZeroMemory(&deviceCaps, sizeof(deviceCaps));
        deviceCaps.Size = sizeof(DEVICE_CAPABILITIES);
        deviceCaps.Version = 1;

        //
        // should initalize deviceCaps.Address and deviceCaps.UINumber here as well
        //
        deviceCaps.Address = (ULONG)-1;
        deviceCaps.UINumber= (ULONG)-1;
        
        //
        //  Get the stack pointer.
        //
        pirpSpN = IoGetNextIrpStackLocation(pirp);
        ASSERT(pirpSpN != NULL);
        NdisZeroMemory(pirpSpN, sizeof(IO_STACK_LOCATION ) );
        
        //
        //  Set the default device state to full on.
        //
        pirpSpN->MajorFunction = IRP_MJ_PNP;
        pirpSpN->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
        pirpSpN->Parameters.DeviceCapabilities.Capabilities = &deviceCaps;
        pirp->IoStatus.Status  = STATUS_NOT_SUPPORTED;
        
        //
        //  Setup the I/O completion routine to be called.
        //
        INITIALIZE_EVENT(&pQuery.Event);
        IoSetCompletionRoutine(pirp,
                               ndisCompletionRoutine,
                               &pQuery,
                               TRUE,
                               TRUE,
                               TRUE);


        //
        //  Call the next driver.
        //
        Status = IoCallDriver(Miniport->NextDeviceObject, pirp);
        if (STATUS_PENDING == Status)
        {
            Status = WAIT_FOR_OBJECT(&pQuery.Event, NULL);
            ASSERT(NT_SUCCESS(Status));
        }

        //
        //  If the lower device object successfully completed the request
        //  then we save that information.
        //
        if (NT_SUCCESS(pQuery.Status))
        {
            
            //
            //  Get the pointer to the device capabilities as returned by
            //  the parent PDO.
            //
            pDeviceCaps = &deviceCaps;
        
            //
            // save the entire device caps received from bus driver/ACPI
            //
            NdisMoveMemory(
                &Miniport->DeviceCaps,
                pDeviceCaps,
                sizeof(DEVICE_CAPABILITIES));


            if ((pDeviceCaps->DeviceWake != PowerDeviceUnspecified) &&
                (pDeviceCaps->SystemWake != PowerSystemUnspecified))
            {
                MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_PM_SUPPORTED);
            }

            IF_DBG(DBG_COMP_PM, DBG_LEVEL_INFO)
            {
                UINT i;
                DbgPrint("ndisQueryPowerCapabilities: Miniport %p, Bus PM capabilities\n", Miniport);
                DbgPrint("\tDeviceD1:\t\t%ld\n", (pDeviceCaps->DeviceD1 == 0) ? 0 : 1);
                DbgPrint("\tDeviceD2:\t\t%ld\n", (pDeviceCaps->DeviceD2 == 0) ? 0 : 1);
                DbgPrint("\tWakeFromD0:\t\t%ld\n", (pDeviceCaps->WakeFromD0 == 0) ? 0 : 1);
                DbgPrint("\tWakeFromD1:\t\t%ld\n", (pDeviceCaps->WakeFromD1 == 0) ? 0 : 1);
                DbgPrint("\tWakeFromD2:\t\t%ld\n", (pDeviceCaps->WakeFromD2 == 0) ? 0 : 1);
                DbgPrint("\tWakeFromD3:\t\t%ld\n\n", (pDeviceCaps->WakeFromD3 == 0) ? 0 : 1);
                
                DbgPrint("\tSystemState\t\tDeviceState\n");

                if (pDeviceCaps->DeviceState[0] ==  PowerDeviceUnspecified)
                    DbgPrint("\tPowerSystemUnspecified\tPowerDeviceUnspecified\n");
                else
                    DbgPrint("\tPowerSystemUnspecified\t\tD%ld\n", pDeviceCaps->DeviceState[0] - 1);

                for (i = 1; i < PowerSystemMaximum; i++)
                {
                    if (pDeviceCaps->DeviceState[i]==  PowerDeviceUnspecified)
                        DbgPrint("\tS%ld\t\t\tPowerDeviceUnspecified\n",i-1);
                    else
                        DbgPrint("\tS%ld\t\t\tD%ld\n",i-1, pDeviceCaps->DeviceState[i] - 1);

                }

                if (pDeviceCaps->SystemWake == PowerSystemUnspecified)
                    DbgPrint("\t\tSystemWake: PowerSystemUnspecified\n");
                else
                    DbgPrint("\t\tSystemWake: S%ld\n", pDeviceCaps->SystemWake - 1);


                if (pDeviceCaps->DeviceWake == PowerDeviceUnspecified)
                    DbgPrint("\t\tDeviceWake: PowerDeviceUnspecified\n");
                else
                    DbgPrint("\t\tDeviceWake: D%ld\n", pDeviceCaps->DeviceWake - 1);

            }
        }
        else
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,("ndisQueryPowerCapabilities: Miniport %p, Bus driver failed IRP_MN_QUERY_CAPABILITIES\n", Miniport));
        }

        //
        //  The irp is no longer needed.
        //
        IoFreeIrp(pirp);
        
    } while (FALSE);
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisQueryPowerCapabilities: Miniport %p, Status 0x%x\n", Miniport, Status));

    return(Status);
}

#ifdef NDIS_MEDIA_DISCONNECT_POWER_OFF
//1 dead code for .NET
NTSTATUS
ndisMediaDisconnectComplete(
    IN  PDEVICE_OBJECT      pdo,
    IN  UCHAR               MinorFunction,
    IN  POWER_STATE         PowerState,
    IN  PVOID               Context,
    IN  PIO_STATUS_BLOCK    IoStatus
    )
/*++

Routine Description:


Arguments:

    pdo         -   Pointer to the DEVICE_OBJECT for the miniport.
    pirp        -   Pointer to the device set power state IRP that we created.
    Context     -   Pointer to the miniport block

Return Value:

--*/
{
    PNDIS_MINIPORT_BLOCK    Miniport = (PNDIS_MINIPORT_BLOCK)Context;
    NTSTATUS                Status = STATUS_MORE_PROCESSING_REQUIRED;
    KIRQL                   OldIrql;

    UNREFERENCED_PARAMETER(pdo);
    UNREFERENCED_PARAMETER(MinorFunction);
    UNREFERENCED_PARAMETER(IoStatus);
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisMediaDisconnectComplete: Miniport %p\n", Miniport));

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);

    //
    //  double check that we didn't get a link up while we were doing all this.
    //
    if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_CANCELLED))
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisMediaDisconnectComplete: Miniport %p, disconnect complete\n", Miniport));

        NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
    }
    else
    {

        MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_CANCELLED);

        NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

        //
        // if system is not going to sleep, wake up the device
        //
        if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_SYSTEM_SLEEPING))
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisMediaDisconnectComplete: Miniport %p, disconnect was cancelled. Power back up the miniport\n", Miniport));

            //
            //  Wake it back up
            //
            PowerState.DeviceState = PowerDeviceD0;
            Status = PoRequestPowerIrp(Miniport->PhysicalDeviceObject,
                                       IRP_MN_SET_POWER,
                                       PowerState,
                                       NULL,
                                       NULL,
                                       NULL);
        }
    }
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisMediaDisconnectComplete: Miniport %p\n", Miniport));

    return(STATUS_MORE_PROCESSING_REQUIRED);
}

//1 dead code for .NET
VOID
ndisMediaDisconnectWorker(
    IN  PPOWER_WORK_ITEM    pWorkItem,
    IN  PVOID               Context
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    PNDIS_MINIPORT_BLOCK    Miniport = (PNDIS_MINIPORT_BLOCK)Context;
    POWER_STATE             PowerState;
    NTSTATUS                Status;
    NDIS_STATUS             NdisStatus;
    ULONG                   WakeEnable;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("==>ndisMediaDisconnectWorker: Miniport %p\n", Miniport));

    //
    //  Determine the minimum device state we can go to and still get a link enabled.
    //
    if (Miniport->DeviceCaps.DeviceWake < Miniport->PMCapabilities.WakeUpCapabilities.MinLinkChangeWakeUp)
    {
        PowerState.DeviceState = Miniport->DeviceCaps.DeviceWake;
    }
    else
    {
        PowerState.DeviceState = Miniport->PMCapabilities.WakeUpCapabilities.MinLinkChangeWakeUp;
    }


    
    //
    // enable the appropriate wakeup method. this includes link change,
    // pattern match and/or magic packet.
    // if LINK_CHANGE method is disabled, we should not even get here
    //
    //
    // Miniport->WakeUpEnable is the wakeup methods enabled from protocol (and ndis point of view)
    // with this qfe, when the user turns wol off from UI, the methods going down are not
    // the methods set by protocol/ndis
    //
    
    WakeEnable = Miniport->WakeUpEnable;

    if (Miniport->PnPCapabilities & NDIS_DEVICE_DISABLE_WAKE_ON_PATTERN_MATCH)
    {
        WakeEnable &= ~NDIS_PNP_WAKE_UP_PATTERN_MATCH;
    }

    if (Miniport->PnPCapabilities & NDIS_DEVICE_DISABLE_WAKE_ON_MAGIC_PACKET)
    {
        WakeEnable &= ~NDIS_PNP_WAKE_UP_MAGIC_PACKET;
    }
                 
    NdisStatus = ndisQuerySetMiniportDeviceState(Miniport,
                                                 WakeEnable,
                                                 OID_PNP_ENABLE_WAKE_UP,
                                                 TRUE);

    if (NdisStatus == NDIS_STATUS_SUCCESS)
    {
        
            
        //
        //  We need to request a device state irp.
        //
        Miniport->WaitWakeSystemState = Miniport->DeviceCaps.SystemWake;
        Status = PoRequestPowerIrp(Miniport->PhysicalDeviceObject,
                                   IRP_MN_SET_POWER,
                                   PowerState,
                                   ndisMediaDisconnectComplete,
                                   Miniport,
                                   NULL);

    }
    
    FREE_POOL(pWorkItem);

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("<==ndisMediaDisconnectWorker: Miniport %p\n", Miniport));
}

//1 dead code for .NET
VOID
ndisMediaDisconnectTimeout(
    IN  PVOID   SystemSpecific1,
    IN  PVOID   Context,
    IN  PVOID   SystemSpecific2,
    IN  PVOID   SystemSpecific3
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    //
    //  Fire off a workitem to take care of this at passive level.
    //
    PNDIS_MINIPORT_BLOCK    Miniport = (PNDIS_MINIPORT_BLOCK)Context;
    PPOWER_WORK_ITEM        pWorkItem;

    UNREFERENCED_PARAMETER(SystemSpecific1);
    UNREFERENCED_PARAMETER(SystemSpecific2);
    UNREFERENCED_PARAMETER(SystemSpecific3);

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisMediaDisconnectTimeout: Miniport %p\n", Miniport));

    
    do
    {
        NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);
        
        if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_WAIT))
        {
            NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisMediaDisconnectTimeout: Miniport %p, media disconnect was cancelled\n", Miniport));
            break;
        }
        
        //
        //  Clear the disconnect wait flag.
        //
        MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_WAIT);
    
        NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);

        pWorkItem = ALLOC_FROM_POOL(sizeof(POWER_WORK_ITEM), NDIS_TAG_WORK_ITEM);
        if (pWorkItem != NULL)
        {
            //
            //  Initialize the ndis work item to power on.
            //
            NdisInitializeWorkItem(&pWorkItem->WorkItem,
                                   (NDIS_PROC)ndisMediaDisconnectWorker,
                                   Miniport);
        
            MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_SEND_WAIT_WAKE);
            
            //
            //  Schedule the workitem to fire.
            //
            NdisScheduleWorkItem(&pWorkItem->WorkItem);
        }
    } while (FALSE);
    
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisMediaDisconnectTimeout: Miniport %p\n", Miniport));
}
#endif

NTSTATUS
ndisWaitWakeComplete(
    IN  PDEVICE_OBJECT      pdo,
    IN  UCHAR               MinorFunction,
    IN  POWER_STATE         PowerState,
    IN  PVOID               Context,
    IN  PIO_STATUS_BLOCK    IoStatus
    )
/*++

Routine Description:


Arguments:

    DeviceObject
    Irp
    Context

Return Value:

--*/
{
    PNDIS_MINIPORT_BLOCK    Miniport = (PNDIS_MINIPORT_BLOCK)Context;
    PIRP                    pirp;
    NTSTATUS                Status = IoStatus->Status;
    POWER_STATE             DevicePowerState;
    KIRQL                   OldIrql;

    UNREFERENCED_PARAMETER(pdo);
    UNREFERENCED_PARAMETER(MinorFunction);
    UNREFERENCED_PARAMETER(PowerState);

    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisWaitWakeComplete: Miniport %p, pIrp %p, Status %lx\n", 
                    Miniport, Miniport->pIrpWaitWake, Status));

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
    pirp = Miniport->pIrpWaitWake;
    Miniport->pIrpWaitWake = NULL;
    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
    
    if (pirp != NULL)
    {

        //
        //  If this completion routine was called because a wake-up occured at the device level
        //  then we need to initiate a device irp to start up the nic.  If it was completed 
        //  due to a cancellation then we skip this since it was cancelled due to a device irp
        //  being sent to wake-up the device.
        //
        
        if (Status == STATUS_SUCCESS)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisWaitWakeComplete: Miniport %p, Wake irp was complete due to wake event\n", Miniport));

            if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_SYSTEM_SLEEPING))
            {
                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                    ("ndisWaitWakeComplete: Miniport %p, Powering up the Miniport\n", Miniport));
                //
                //  We need to request a set power to power up the device.
                //
                DevicePowerState.DeviceState = PowerDeviceD0;
                Status = PoRequestPowerIrp(Miniport->PhysicalDeviceObject,
                                           IRP_MN_SET_POWER,
                                           DevicePowerState,
                                           NULL,
                                           NULL,
                                           NULL);
            }
            else
            {
                //
                // it is also possible that the device woke up the whole system (WOL) in which case we
                // will get a system power IRP eventually and we don't need to request a power IRP.
                //
                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                    ("ndisWaitWakeComplete: Miniport %p woke up the system.\n", Miniport));
                
            }
        }
        else
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisWaitWakeComplete: Miniport %p, WAIT_WAKE irp failed or cancelled. Status %lx\n",
                    Miniport, Status));

        }

    }
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisWaitWakeComplete: Miniport %p\n", Miniport));
    
    return(STATUS_MORE_PROCESSING_REQUIRED);
}

NTSTATUS
ndisQueryPowerComplete(
    IN  PDEVICE_OBJECT  pdo,
    IN  PIRP            pirp,
    IN  PVOID           Context
    )
/*++

Routine Description:


Arguments:

    pdo     -   Pointer to the device object
    pirp    -   Pointer to the query power irp
    Context -   Pointer to the miniport.

Return Value:

--*/
{
    NTSTATUS    Status = pirp->IoStatus.Status;

    UNREFERENCED_PARAMETER(pdo);
#if !DBG
    UNREFERENCED_PARAMETER(Context);
#endif

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisQueryPowerComplete: Miniport %p, Bus driver returned %lx for QueryPower\n",
            Context, pirp->IoStatus.Status));
        
#ifdef TRACE_PM_PROBLEMS
    if (!NT_SUCCESS(pirp->IoStatus.Status))
    {
        DbgPrint("ndisQueryPowerComplete: Miniport %p, Bus Driver returned %lx for QueryPower.\n",
            Context, pirp->IoStatus.Status);
    }
#endif

    PoStartNextPowerIrp(pirp);

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisQueryPowerComplete: Miniport %p\n", Context));

    return(Status);
}

NTSTATUS
ndisQueryPower(
    IN  PIRP                    pirp,
    IN  PIO_STACK_LOCATION      pirpSp,
    IN  PNDIS_MINIPORT_BLOCK    Miniport
    )
/*++

Routine Description:

    This routine will process the IRP_MN_QUERY_POWER for a miniport driver.

Arguments:

    pirp        -   Pointer to the IRP.
    pirpSp      -   Pointer to the IRPs current stack location.
    Adapter     -   Pointer to the adapter.

Return Value:

--*/
{
    NTSTATUS                Status = STATUS_SUCCESS;
    DEVICE_POWER_STATE      DeviceState = PowerDeviceUnspecified;
    NDIS_STATUS             NdisStatus;
    PIO_STACK_LOCATION      pirpSpN;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisQueryPower: Miniport %p\n", Miniport));

    do
    {
        //
        //  We only handle system power states sent as a query.
        //
        if (pirpSp->Parameters.Power.Type != SystemPowerState)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisQueryPower: Miniport %p, Not a system state! Type: 0x%x. State: 0x%x\n",
                    Miniport, pirpSp->Parameters.Power.Type, pirpSp->Parameters.Power.State));
    
            Status = STATUS_INVALID_DEVICE_REQUEST;

            break;
        }

        //
        //  Determine if the system state is appropriate and what device state we
        //  should go to.
        //
        Status = ndisMPowerPolicy(Miniport,
                                  pirpSp->Parameters.Power.State.SystemState,
                                  &DeviceState,
                                  TRUE);

        

        if (!ndisIsMiniportStarted(Miniport) ||
            (Miniport->PnPDeviceState != NdisPnPDeviceStarted) ||
            (STATUS_DEVICE_POWERED_OFF == Status))
        {       
            pirp->IoStatus.Status = STATUS_SUCCESS;
    
            PoStartNextPowerIrp(pirp);
            IoCompleteRequest(pirp, 0);
            return(STATUS_SUCCESS);
        }

        //
        //  If we didn't succeed then fail the query power.
        //
        if (!NT_SUCCESS(Status))
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisQueryPower: Miniport %p, Unable to go to system state 0x%x\n",
                    Miniport, pirpSp->Parameters.Power.State.SystemState));

            break;
        }

        //
        //  Notify the transports with the query power PnP event.
        //
        NdisStatus = ndisPnPNotifyAllTransports(Miniport,
                                                NetEventQueryPower,
                                                &DeviceState,
                                                sizeof(DeviceState));
        if (NDIS_STATUS_SUCCESS != NdisStatus)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                ("ndisQueryPower: Miniport %p, ndisPnPNotifyAllTransports failed\n", Miniport));

            Status = NdisStatus;
            break;
        }

        //
        //  Notify the miniport...
        //
        if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_ENABLE))
        {
            
            NdisStatus = ndisQuerySetMiniportDeviceState(Miniport,
                                                         DeviceState,
                                                         OID_PNP_QUERY_POWER,
                                                         FALSE);

            if (NDIS_STATUS_SUCCESS != NdisStatus)
            {
                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                    ("ndisQueryPower: Miniport %p, failed query power\n", Miniport));
                    
                Status = STATUS_UNSUCCESSFUL;
                break;
            }
        }

    } while (FALSE);

    if (!NT_SUCCESS(Status))
    {
        pirp->IoStatus.Status = Status;
        PoStartNextPowerIrp(pirp);
        IoCompleteRequest(pirp, 0);
    }
    else
    {
        //
        //  Pass this irp down the stack.
        //
        pirpSpN = IoGetNextIrpStackLocation(pirp);
        pirpSpN->MajorFunction = IRP_MJ_POWER;
        pirpSpN->MinorFunction = IRP_MN_QUERY_POWER;

        pirpSpN->Parameters.Power.SystemContext = pirpSp->Parameters.Power.SystemContext;
        pirpSpN->Parameters.Power.Type = DevicePowerState;
        pirpSpN->Parameters.Power.State.DeviceState = DeviceState;

        IoSetCompletionRoutine(
            pirp,
            ndisQueryPowerComplete,
            Miniport,
            TRUE,
            TRUE,
            TRUE);

        IoMarkIrpPending(pirp);
        PoCallDriver(Miniport->NextDeviceObject, pirp);
        Status = STATUS_PENDING;

        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisQueryPower: Miniport %p, PoCallDriver to NextDeviceObject returned %lx\n", Miniport, Status));

    }

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisQueryPower: Miniport %p\n", Miniport));

    return(Status);
}

VOID
FASTCALL
ndisPmHaltMiniport(
    IN PNDIS_MINIPORT_BLOCK Miniport
    )
/*++

Routine Description:

    This will stop the miniport from functioning...

Arguments:

    Miniport - pointer to the mini-port to halt

Return Value:

    None.

--*/

{
    KIRQL   OldIrql;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisPmHaltMiniport: Miniport \n", Miniport));

    PnPReferencePackage();

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);

    NdisResetEvent(&Miniport->OpenReadyEvent);

    if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_PM_HALTED))
    {
        ASSERT(FALSE);
        NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
        return;
    }
    //
    //  Mark this miniport as halting.
    //
    MINIPORT_SET_FLAG(Miniport, fMINIPORT_PM_HALTING);
    MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_PM_HALTED);

    MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_NORMAL_INTERRUPTS);
    MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_NO_SHUTDOWN);

    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

    ndisMCommonHaltMiniport(Miniport);

    NdisMDeregisterAdapterShutdownHandler(Miniport);

    Miniport->MiniportAdapterContext = NULL;

    PnPDereferencePackage();

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisPmHaltMiniport: Miniport %p\n", Miniport));
}

NDIS_STATUS
ndisPmInitializeMiniport(
    IN  PNDIS_MINIPORT_BLOCK    Miniport
    )
/*++

Routine Description:

    This routine will re-initialize a miniport that has been halted due to
    a PM low power transition.

Arguments:

    Miniport    -   Pointer to the miniport block to re-initialize.

Return Value:

--*/
{
    PNDIS_M_DRIVER_BLOCK                pMiniBlock = Miniport->DriverHandle;
    NDIS_WRAPPER_CONFIGURATION_HANDLE   ConfigurationHandle;
    NDIS_STATUS                         Status;
    NDIS_STATUS                         OpenErrorStatus;
    UINT                                SelectedMediumIndex;
    ULONG                               Flags;
    KIRQL                               OldIrql;
    UCHAR                               SendFlags;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisPmInitializeMiniport: Miniport %p\n", Miniport));
    
    do
    {
        if ((Miniport->DmaAdapterRefCount == 1) &&
            (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_SG_LIST)))
        {
            Miniport->DmaResourcesReleasedEvent = NULL;
            ndisDereferenceDmaAdapter(Miniport);
            MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_SG_LIST);
        }
        
        MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_PM_HALTING |
                                      fMINIPORT_DEREGISTERED_INTERRUPT |
                                      fMINIPORT_RESET_REQUESTED |
                                      fMINIPORT_RESET_IN_PROGRESS);
                                      
        MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_REMOVE_IN_PROGRESS);

        Flags = Miniport->Flags;
        SendFlags = Miniport->SendFlags;

        //
        //  Clean up any workitems that might have been queue'd
        //
        NDISM_DEQUEUE_WORK_ITEM(Miniport, NdisWorkItemMiniportCallback, NULL);
        NDISM_DEQUEUE_WORK_ITEM(Miniport, NdisWorkItemRequest, NULL);
        NDISM_DEQUEUE_WORK_ITEM(Miniport, NdisWorkItemSend, NULL);
        NDISM_DEQUEUE_WORK_ITEM(Miniport, NdisWorkItemResetRequested, NULL);
        NDISM_DEQUEUE_WORK_ITEM(Miniport, NdisWorkItemResetInProgress, NULL);
        InitializeListHead(&Miniport->PacketList);

        //
        //  Initialize the configuration handle for use during the initialization.
        //
        ConfigurationHandle.DriverObject = Miniport->DriverHandle->NdisDriverInfo->DriverObject;
        ConfigurationHandle.DeviceObject = Miniport->DeviceObject;
        ConfigurationHandle.DriverBaseName = &Miniport->BaseName;

        ASSERT(KeGetCurrentIrql() == 0);
        Status = ndisInitializeConfiguration((PNDIS_WRAPPER_CONFIGURATION_HANDLE)&ConfigurationHandle,
                                             Miniport,
                                             NULL);
        ASSERT(KeGetCurrentIrql() == 0);

        if (NDIS_STATUS_SUCCESS != Status)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                ("ndisPmInitializeMiniport: Miniport %p, ndisInitializeConfiguration failed, Status: 0x%x\n", Miniport, Status));
            break;
        }
    
        //
        // Call adapter callback. The current value for "Export"
        // is what we tell him to name this device.
        //
        MINIPORT_SET_FLAG(Miniport, fMINIPORT_IN_INITIALIZE);
        MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_NORMAL_INTERRUPTS);
        Miniport->CurrentDevicePowerState = PowerDeviceD0;
    
        Status = (pMiniBlock->MiniportCharacteristics.InitializeHandler)(
                    &OpenErrorStatus,
                    &SelectedMediumIndex,
                    ndisMediumArray,
                    ndisMediumArraySize / sizeof(NDIS_MEDIUM),
                    (NDIS_HANDLE)Miniport,
                    (NDIS_HANDLE)&ConfigurationHandle);
    
        ASSERT(KeGetCurrentIrql() == 0);

        if (NDIS_STATUS_SUCCESS != Status)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                ("ndisPmInitializeMiniport: Miniport %p, MiniportInitialize handler failed, Status 0x%x\n", Miniport, Status));
    
            break;
        }
        
        ASSERT (Miniport->MediaType == ndisMediumArray[SelectedMediumIndex]);
        
        //
        // Restore saved settings. make sure we don't overwrite the 
        // fMINIPORT_SG_LIST flag set during initialization.
        //
        Flags |= (Miniport->Flags & fMINIPORT_SG_LIST);
        Miniport->Flags = Flags;
        Miniport->SendFlags = SendFlags;
        
        MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_PM_HALTED | fMINIPORT_REJECT_REQUESTS);
        MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_IN_INITIALIZE);
        CHECK_FOR_NORMAL_INTERRUPTS(Miniport);

        //
        //  Clear the flag preventing the miniport's shutdown handler from being
        //  called if needed.
        //
        MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_NO_SHUTDOWN);

        //
        // if device does not need polling for connect status then assume it is connected
        // as we always do when we intialize a miniport. if it does require media polling
        // leave the media status as it was before suspend. it will be updated on the very first
        // wakeup DPC.
        //
        if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_REQUIRES_MEDIA_POLLING))
        {
            MINIPORT_SET_FLAG(Miniport, fMINIPORT_MEDIA_CONNECTED);
        }

        if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_MEDIA_CONNECTED))
        {
            //
            // set the ReceivePacket handler
            //
            ndisMSetIndicatePacketHandler(Miniport);
        }

        BLOCK_LOCK_MINIPORT_LOCKED(Miniport, OldIrql);

        //
        //  Restore the filter information.
        //
        ndisMRestoreFilterSettings(Miniport, NULL, FALSE);

        //
        //  Make sure the filter settings get updated.
        //
        if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_DESERIALIZE))
        {
            ndisMDoRequests(Miniport);
        }
        else
        {
            NDISM_PROCESS_DEFERRED(Miniport);
        }

        UNLOCK_MINIPORT_L(Miniport);

        //
        //  Start up the wake up timer.
        //
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisPmInitializeMiniport: Miniport %p, startup the wake-up DPC timer\n", Miniport));


        MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_CANCEL_WAKE_UP_TIMER);
        
        NdisSetTimer(&Miniport->WakeUpDpcTimer, Miniport->CheckForHangSeconds*1000);    

        NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

        ASSERT(KeGetCurrentIrql() == 0);


        if (Miniport->MediaType == NdisMedium802_3)
        {
            ndisMNotifyMachineName(Miniport, NULL);
        }

        //
        // Register with WMI.
        //
        Status = IoWMIRegistrationControl(Miniport->DeviceObject, WMIREG_ACTION_REGISTER);

        if (!NT_SUCCESS(Status))
        {
            //
            //  This should NOT keep the adapter from initializing but we should log the error.
            //
            DBGPRINT_RAW((DBG_COMP_INIT | DBG_COMP_WMI), DBG_LEVEL_WARN,
                ("ndisPmInitializeMiniport: Miniport %p, Failed to register for WMI support\n", Miniport));
        }

        Status = NDIS_STATUS_SUCCESS;
        
        KeQueryTickCount(&Miniport->NdisStats.StartTicks);
        
    } while (FALSE);

    if (NDIS_STATUS_SUCCESS != Status)
    {
        NdisMDeregisterAdapterShutdownHandler(Miniport);
        
        ndisLastFailedInitErrorCode =  Status;
        ASSERT(Miniport->Interrupt == NULL);
        ASSERT(Miniport->TimerQueue == NULL);
        ASSERT(Miniport->MapRegisters == NULL);

        if ((Miniport->TimerQueue != NULL) || (Miniport->Interrupt != NULL))
        {
            if (Miniport->Interrupt != NULL)
            {
                BAD_MINIPORT(Miniport, "Unloading without deregistering interrupt");
                KeBugCheckEx(BUGCODE_NDIS_DRIVER,
                            0x10,
                            (ULONG_PTR)Miniport,
                            (ULONG_PTR)Miniport->Interrupt,
                            0);
            }
            else
            {
                BAD_MINIPORT(Miniport, "Unloading without deregistering timer");
                KeBugCheckEx(BUGCODE_NDIS_DRIVER,
                            0x11,
                            (ULONG_PTR)Miniport,
                            (ULONG_PTR)Miniport->TimerQueue,
                            0);
            }
        }
    
        MINIPORT_SET_FLAG(Miniport, fMINIPORT_PM_HALTING);
        MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_PM_HALTED);
        MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_NORMAL_INTERRUPTS);
        
    }

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisPmInitializeMiniport: Miniport %p\n", Miniport));

    return(Status);
}

NDIS_STATUS
ndisQuerySetMiniportDeviceState(
    IN  PNDIS_MINIPORT_BLOCK    Miniport,
    IN  DEVICE_POWER_STATE      DeviceState,
    IN  NDIS_OID                Oid,
    IN  BOOLEAN                 fSet
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    NDIS_STATUS             NdisStatus;
    NDIS_REQUEST            PowerReq;
    PNDIS_COREQ_RESERVED    CoReqRsvd;
    ULONG                   State;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("==>ndisQuerySetMiniportDeviceState: Miniport %p\n", Miniport));

    //
    //  Setup the miniport's internal request for a set power OID.
    //
    CoReqRsvd = PNDIS_COREQ_RESERVED_FROM_REQUEST(&PowerReq);
    INITIALIZE_EVENT(&CoReqRsvd->Event);

    PowerReq.DATA.SET_INFORMATION.InformationBuffer = &State;
    PowerReq.DATA.SET_INFORMATION.InformationBufferLength = sizeof(State);

    PowerReq.RequestType = fSet ? NdisRequestSetInformation : NdisRequestQueryInformation;

    PowerReq.DATA.SET_INFORMATION.Oid = Oid;
    PowerReq.DATA.SET_INFORMATION.InformationBuffer = &DeviceState;
    PowerReq.DATA.SET_INFORMATION.InformationBufferLength = sizeof(DeviceState);

    NdisStatus = ndisQuerySetMiniport(Miniport,
                                      NULL,
                                      fSet,
                                      &PowerReq,
                                      NULL);

#ifdef TRACE_PM_PROBLEMS
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        DbgPrint("ndisQuerySetMiniportDeviceState: Miniport %p, (Name: %p) failed Oid %lx, Set = %lx with error %lx\n",
                        Miniport,
                        Miniport->pAdapterInstanceName,
                        Oid,
                        fSet,
                        NdisStatus);
    }
#endif

                    
    //
    //  Miniport can't fail the set power request.
    //
    if (fSet)
    {
        ASSERT(NDIS_STATUS_SUCCESS == NdisStatus);
    }
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("<==ndisQuerySetMiniportDeviceState: Miniport %p, Status %lx\n", Miniport, NdisStatus));

    return(NdisStatus);
}


NTSTATUS
ndisRequestedDevicePowerIrpComplete(
    IN  PDEVICE_OBJECT      pdo,
    IN  UCHAR               MinorFunction,
    IN  POWER_STATE         PowerState,
    IN  PVOID               Context,
    IN  PIO_STATUS_BLOCK    IoStatus
    )
/*++

Routine Description:
    This is the callback routine for completion of a -device- power IRP
    that NDIS requested while handling a system power IRP. We will call
    PoStartNextPowerIrp and complete the system IRP or send it down to 
    the next driver depending on the status code of our -device- power
    IRP.

Arguments:

    pdo         -   Pointer to the physical DEVICE_OBJECT for the miniport.
    Context     -   Pointer to the system set power state sent by the OS.

Return Value:

--*/
{
    PIRP                    pirpSystem = Context;
    PIO_STACK_LOCATION      pirpSp;
    PNDIS_MINIPORT_BLOCK    Miniport;

#if !DBG
    UNREFERENCED_PARAMETER(pdo);
#endif
    UNREFERENCED_PARAMETER(MinorFunction);
    UNREFERENCED_PARAMETER(PowerState);
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisRequestedDevicePowerIrpComplete: DeviceObject %p\n", pdo));

    //
    //  Save the status code with the original IRP.
    //
    pirpSystem->IoStatus = *IoStatus;

    //
    //  did everything go well?
    //
    if (NT_SUCCESS(IoStatus->Status))
    {
        //
        //  Get current stack pointer.
        //
        pirpSp = IoGetCurrentIrpStackLocation(pirpSystem);

        ASSERT(SystemPowerState == pirpSp->Parameters.Power.Type);
        
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisRequestedDevicePowerIrpComplete: DeviceObject %p, Going to system power state %lx\n",
                pdo, pirpSp->Parameters.Power.State));

        //
        //  Notify the system that we are in the appropriate power state.
        //
        PoSetPowerState(pirpSp->DeviceObject,SystemPowerState, pirpSp->Parameters.Power.State);
        
        Miniport = (PNDIS_MINIPORT_BLOCK)((PNDIS_WRAPPER_CONTEXT)pirpSp->DeviceObject->DeviceExtension + 1);

        PoStartNextPowerIrp(pirpSystem);

        //
        // now send down the System power IRP
        //
        IoCopyCurrentIrpStackLocationToNext(pirpSystem);
        PoCallDriver(Miniport->NextDeviceObject, pirpSystem);
    }
    else
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
            ("ndisRequestedDevicePowerIrpComplete: DeviceObject %p, IRP_MN_SET_POWER failed!\n", pdo));
            
        PoStartNextPowerIrp(pirpSystem);
        IoCompleteRequest(pirpSystem, 0);

    }


    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisRequestedDevicePowerIrpComplete: DeviceObject %p\n", pdo));

    return(STATUS_MORE_PROCESSING_REQUIRED);
}

NTSTATUS
ndisSetSystemPowerOnComplete(
    IN  PDEVICE_OBJECT      pdo,
    IN  PIRP                pirp,
    IN  PVOID               Context
    )
/*++

Routine Description:

    Completion routine for S0 irp. This routine requests a D0 irp to be sent down the stack.

Arguments:

    pdo         -   Pointer to the DEVICE_OBJECT for the miniport.
    pirp        -   Pointer to the S0 irp sent by the power manager.
    Context     -   Pointer to the miniport context

Return Value:

--*/
{
    PIO_STACK_LOCATION      pirpSp = IoGetCurrentIrpStackLocation(pirp);
    PNDIS_MINIPORT_BLOCK    Miniport = Context;
    POWER_STATE PowerState;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisSetSystemPowerOnComplete: DeviceObject %p\n", pdo));

    //
    //  did everything go well?
    //
    if (NT_SUCCESS(pirp->IoStatus.Status))
    {
        //
        //  Request the D irp now.
        //
        PowerState.DeviceState = PowerDeviceD0;
        PoRequestPowerIrp(Miniport->PhysicalDeviceObject,
                          IRP_MN_SET_POWER,
                          PowerState,
                          NULL,
                          NULL,
                          NULL);
        
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisSetSystemPowerOnComplete: DeviceObject %p, Going to system power state %lx\n",
                pdo, PowerState));

        //
        //  Notify the system that we are in the appropriate power state.
        //
        PoSetPowerState(pdo ,SystemPowerState, pirpSp->Parameters.Power.State);
    }

    PoStartNextPowerIrp(pirp);

    return(STATUS_SUCCESS);
}

VOID
ndisDevicePowerOn(
    IN  PPOWER_WORK_ITEM    pWorkItem,
    IN  PVOID               pContext
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    PNDIS_MINIPORT_BLOCK    Miniport = (PNDIS_MINIPORT_BLOCK)pContext;
    DEVICE_POWER_STATE      DeviceState;
    POWER_STATE             PowerState;
    NDIS_STATUS             NdisStatus;
    PIRP                    pirp;
    PIO_STACK_LOCATION      pirpSp;
    NTSTATUS                NtStatus;
    NDIS_POWER_PROFILE      PowerProfile;
    BOOLEAN                 fNotifyProtocols = FALSE;
    BOOLEAN                 fStartMediaDisconnectTimer = FALSE;
    KIRQL                   OldIrql;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisDevicePowerOn: Miniport %p\n", Miniport));
        
    PnPReferencePackage();
    
    pirp = pWorkItem->pIrp;
    pirpSp = IoGetCurrentIrpStackLocation(pirp);
    DeviceState = pirpSp->Parameters.Power.State.DeviceState;

#ifdef TRACE_PM_PROBLEMS
    if (!NT_SUCCESS(pirp->IoStatus.Status))
    {
        DbgPrint("ndisDevicePowerOn: Miniport %p, Bus Driver returned %lx for Powering up the Miniport.\n",
                    Miniport, pirp->IoStatus.Status);
    }
#endif

    if (NT_SUCCESS(pirp->IoStatus.Status))
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisDevicePowerOn: Miniport %p, Bus driver succeeded power up\n", Miniport));

        //
        //  If the device is not in D0 then we need to wake up the miniport and
        //  restore the handlers.
        //
        if (Miniport->CurrentDevicePowerState != PowerDeviceD0)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisDevicePowerOn: Miniport %p, Power up the Miniport\n", Miniport));

            //
            //  What type of miniport was this?
            //
            if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_ENABLE))
            {
                //
                //  Set the miniport's device state.
                //
                NdisStatus = ndisQuerySetMiniportDeviceState(Miniport, 
                                                             DeviceState,
                                                             OID_PNP_SET_POWER,
                                                             TRUE);
                ASSERT(KeGetCurrentIrql() == 0);

                if (NdisStatus == NDIS_STATUS_SUCCESS)
                    Miniport->CurrentDevicePowerState = DeviceState;


                //
                // Start wake up timer
                //
                MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_CANCEL_WAKE_UP_TIMER);
                
                NdisSetTimer(&Miniport->WakeUpDpcTimer, Miniport->CheckForHangSeconds*1000);
                
            }
            else
            {
                ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);

                if (((Miniport->DriverHandle->Flags & fMINIBLOCK_INTERMEDIATE_DRIVER) == 0) &&
                    (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_PM_HALTED)))
                {                    
                    NdisStatus = ndisPmInitializeMiniport(Miniport);
                    ASSERT(KeGetCurrentIrql() == 0);
                }
                else
                {
                    NdisStatus = NDIS_STATUS_SUCCESS;               
                }
            }

            if (NDIS_STATUS_SUCCESS == NdisStatus)
            {
                if (ndisIsMiniportStarted(Miniport))
                {
                    NdisSetEvent(&Miniport->OpenReadyEvent);
                    //
                    //  Restore the handlers.
                    //
                    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
                    ndisMRestoreOpenHandlers(Miniport, fMINIPORT_STATE_PM_STOPPED);
                    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
                    
                    ASSERT(KeGetCurrentIrql() == 0);

                    ASSERT(Miniport->SymbolicLinkName.Buffer != NULL);
                    
                    if (Miniport->SymbolicLinkName.Buffer != NULL)
                    {
                        NtStatus = IoSetDeviceInterfaceState(&Miniport->SymbolicLinkName, TRUE);
                    }
                    else
                    {
                        NtStatus = STATUS_UNSUCCESSFUL;
                    }
                    
                    if (!NT_SUCCESS(NtStatus))
                    {
                        DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_ERR,
                            ("ndisDevicePowerOn: IoRegisterDeviceClassAssociation failed: Miniport %p, Status %lx\n", Miniport, NtStatus));
                    }

                    fNotifyProtocols = TRUE;
                    fStartMediaDisconnectTimer = TRUE;

                    //
                    // let the adapter know about the current power source
                    //
                    PowerProfile = ((BOOLEAN)ndisAcOnLine == TRUE) ? 
                                    NdisPowerProfileAcOnLine : 
                                    NdisPowerProfileBattery;

                    ndisNotifyMiniports(Miniport,
                                        NdisDevicePnPEventPowerProfileChanged,
                                        &PowerProfile,
                                        sizeof(NDIS_POWER_PROFILE));

                }
                
                //
                //  Save the new power state the device is in.
                //
                Miniport->CurrentDevicePowerState = DeviceState;
            
                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                    ("ndisDevicePowerOn: Miniport %p, Going to device state 0x%x\n", Miniport, DeviceState));
            
                //
                //  Notify the system that we are in the new device state.
                //
                PowerState.DeviceState = DeviceState;
                PoSetPowerState(Miniport->DeviceObject, DevicePowerState, PowerState);
            }
            else
            {
                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                    ("ndisDevicePowerOn: Miniport %p, Power on failed by device driver for the Miniport, Error %lx!\n",
                        Miniport, NdisStatus));
                    
#ifdef TRACE_PM_PROBLEMS
                DbgPrint("ndisDevicePowerOn: Miniport %p, Device Driver failed powering up Miniport with Error %lx.\n",
                        Miniport,
                        NdisStatus);
#endif
                pirp->IoStatus.Status = STATUS_UNSUCCESSFUL;
            }
        }
        else
        {
            //
            // device is already in D0. we are here because of a cancel of QueryPower
            //
            if (ndisIsMiniportStarted(Miniport) && 
                (Miniport->PnPDeviceState == NdisPnPDeviceStarted))
            {
                //
                // even if the current state of the device is D0, we 
                // need to notify the protocol. because we could be getting
                // this IRP as a cancel to a query IRP -or- the device
                // never lost its D0 state, but the sytem went to sleep
                // and woke up!
                //
                NdisSetEvent(&Miniport->OpenReadyEvent);

                //
                //  Restore the handlers.
                //
                NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
                ndisMRestoreOpenHandlers(Miniport, fMINIPORT_STATE_PM_STOPPED);
                NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

                fNotifyProtocols = TRUE;
                fStartMediaDisconnectTimer = FALSE;

            }
    
        }
    }

    NtStatus = pirp->IoStatus.Status;
    PoStartNextPowerIrp(pirp);
    IoCompleteRequest(pirp, 0);

    //
    // notify the protocols here after completing the power IRP
    // to avoid deadlocks when protocols block on a request that can only
    // complete when the other power IRPs go through
    //
    
    //
    //  Handle the case where the device was not able to power up.
    //
    if (!NT_SUCCESS(NtStatus))
    {
    
#ifdef TRACE_PM_PROBLEMS
        DbgPrint("ndisDevicePowerOn: Miniport %p, Bus or Device failed powering up the Miniport with Error %lx.\n",
                Miniport,
                NtStatus);
#endif

        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                ("ndisDevicePowerOn: Miniport %p, Power on failed by bus or device driver for Miniport with Error %lx!\n",
                Miniport, NtStatus));

        //
        //  Mark the miniport as having failed so that we remove it correctly.
        //
        MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_DEVICE_FAILED);
        
        //
        //  We need to tell pnp that the device state has changed.
        //
        IoInvalidateDeviceState(Miniport->PhysicalDeviceObject);
        ASSERT(KeGetCurrentIrql() == 0);
    }


    if (fNotifyProtocols)
    {
        //
        // for some protocols we may have closed the binding
        //
        ndisCheckAdapterBindings(Miniport, NULL);
        
        //
        //  Notify the transports.
        //
        ndisPnPNotifyAllTransports(Miniport,
                                   NetEventSetPower,
                                   &DeviceState,
                                   sizeof(DeviceState));
        
        ndisNotifyDevicePowerStateChange(Miniport, DeviceState);

        //
        // if media state has changed from disconnect to connect
        // and the last indicated status was disconnect,
        // we should notify the protcols (and Ndis) that the media is
        // connected
        //
        if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_INDICATED) && 
            MINIPORT_TEST_FLAG(Miniport, fMINIPORT_MEDIA_CONNECTED))
        {
            BLOCK_LOCK_MINIPORT_LOCKED(Miniport, OldIrql);
            NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
            MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_MEDIA_CONNECTED);
        
            NdisMIndicateStatus(Miniport,
                    NDIS_STATUS_MEDIA_CONNECT,
                    INTERNAL_INDICATION_BUFFER,
                    INTERNAL_INDICATION_SIZE);
            NdisMIndicateStatusComplete(Miniport);

            UNLOCK_MINIPORT_L(Miniport);
            LOWER_IRQL(OldIrql, DISPATCH_LEVEL);
        }

        //
        // check the media status and if it is disconnected, start the timer
        //
        //1 dead code for .NET
#ifdef NDIS_MEDIA_DISCONNECT_POWER_OFF
        if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_MEDIA_CONNECTED) &&
            fStartMediaDisconnectTimer)
        {
            if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_ENABLE) &&
                (Miniport->WakeUpEnable & NDIS_PNP_WAKE_UP_LINK_CHANGE) &&
                (Miniport->MediaDisconnectTimeOut != (USHORT)(-1)))
            {
                //
                //  Are we already waiting for the disconnect timer to fire?
                //
                if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_WAIT))
                {
                    //
                    //  Mark the miniport as disconnecting and fire off the
                    //  timer.
                    //
                    MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_CANCELLED);
                    MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_WAIT);

                    NdisSetTimer(&Miniport->MediaDisconnectTimer, Miniport->MediaDisconnectTimeOut * 1000);
                }
            }
        }
#endif 
    }

    ASSERT(KeGetCurrentIrql() == 0);

    MINIPORT_DECREMENT_REF(Miniport);

    FREE_POOL(pWorkItem);
    
    PnPDereferencePackage();
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisDevicePowerOn: Miniport %p\n", Miniport));
}


NTSTATUS
ndisSetDevicePowerOnComplete(
    IN  PDEVICE_OBJECT  pdo,
    IN  PIRP            pirp,
    IN  PVOID           pContext
    )
/*++

Routine Description:


Arguments:

    pdo     -   Pointer to the device object for the miniport.
    pirp    -   Pointer to the device set power state IRP that was completed.
    Context -   Not used

Return Value:

--*/
{
    PNDIS_MINIPORT_BLOCK    Miniport = (PNDIS_MINIPORT_BLOCK)pContext;
    PPOWER_WORK_ITEM        pWorkItem;
    DEVICE_POWER_STATE      DeviceState;
    POWER_STATE             PowerState;
    PIO_STACK_LOCATION      pirpSp;

    UNREFERENCED_PARAMETER(pdo);

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisSetDevicePowerOnComplete: Miniport %p, Irp %p, Status %lx\n",
            Miniport, pirp, pirp->IoStatus.Status));

    do
    {
        if (Miniport->PnPDeviceState != NdisPnPDeviceStarted)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisSetDevicePowerOnComplete: Miniport %p is not started yet.\n", Miniport));
                
            pirpSp = IoGetCurrentIrpStackLocation(pirp);
            DeviceState = pirpSp->Parameters.Power.State.DeviceState;
                
            //
            //  Notify the system that we are in the new device state.
            //
            Miniport->CurrentDevicePowerState = DeviceState;
            PowerState.DeviceState = DeviceState;
            PoSetPowerState(Miniport->DeviceObject, DevicePowerState, PowerState);
                
            PoStartNextPowerIrp(pirp);
            IoCompleteRequest(pirp, 0);
            break;
        }
        pWorkItem = ALLOC_FROM_POOL(sizeof(POWER_WORK_ITEM), NDIS_TAG_WORK_ITEM);
        if (pWorkItem == NULL)
        {
            pirp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;

            PoStartNextPowerIrp(pirp);
            IoCompleteRequest(pirp, 0);
            break;
        }

        //
        //  Initialize the ndis work item to power on.
        //
        NdisInitializeWorkItem(&pWorkItem->WorkItem,
                               (NDIS_PROC)ndisDevicePowerOn,
                               Miniport);
        pWorkItem->pIrp = pirp;

        //
        // this reference and corresponding dereference in ndisDevicePowerOn is done
        // to ensure ndis does not return back from REMOVE IRP while we are waiting
        // for ndisDevicePowerOn to fire.
        //
        MINIPORT_INCREMENT_REF_NO_CHECK(Miniport);

        //
        //  Schedule the workitem to fire.
        //
        INITIALIZE_WORK_ITEM((PWORK_QUEUE_ITEM)(&pWorkItem->WorkItem.WrapperReserved),
                             ndisWorkItemHandler,
                             &pWorkItem->WorkItem);
        XQUEUE_WORK_ITEM((PWORK_QUEUE_ITEM)(&pWorkItem->WorkItem.WrapperReserved), DelayedWorkQueue);
    } while (FALSE);
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisSetDevicePowerOnComplete: Miniport %p\n", Miniport));

    return(STATUS_MORE_PROCESSING_REQUIRED);
}


VOID
ndisDevicePowerDown(
    IN  PPOWER_WORK_ITEM    pWorkItem,
    IN  PVOID               pContext
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    PNDIS_MINIPORT_BLOCK    Miniport = (PNDIS_MINIPORT_BLOCK)pContext;
    DEVICE_POWER_STATE      DeviceState;
    POWER_STATE             PowerState;
    NDIS_STATUS             NdisStatus;
    PIRP                    pirp;
    PIO_STACK_LOCATION      pirpSp;
    KIRQL                   OldIrql;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisDevicePowerDown: Miniport %p\n", Miniport));

    PnPReferencePackage();

    pirp = pWorkItem->pIrp;
    pirpSp = IoGetCurrentIrpStackLocation(pirp);
    DeviceState = pirpSp->Parameters.Power.State.DeviceState;

    //
    //  If the complete status is successful then we need to continue with
    //  wakeing the stack.
    //
    if (NT_SUCCESS(pirp->IoStatus.Status))
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisDevicePowerDown: Miniport %p, going to device state 0x%x\n", Miniport, DeviceState));

        //
        //  Build a power state.
        //
        PowerState.DeviceState = DeviceState;

        //
        //  Save the current device state with the miniport block.
        //
        Miniport->CurrentDevicePowerState = DeviceState;

        //
        //  Let the system know about the devices new power state.
        //
        PoSetPowerState(Miniport->DeviceObject, DevicePowerState, PowerState);
    }
    else if (ndisIsMiniportStarted(Miniport) && 
            (Miniport->PnPDeviceState == NdisPnPDeviceStarted))
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
            ("ndisDevicePowerDown: Miniport %p, Bus driver failed to power down the Miniport\n", Miniport));
            
#ifdef TRACE_PM_PROBLEMS
            DbgPrint("ndisDevicePowerDown: Miniport %p, Bus Driver returned %lx for Powering Down the Miniport\n",
                Miniport, pirp->IoStatus.Status);
#endif

        //
        //  We need to go back to the current device state.
        //
        PowerState.DeviceState = Miniport->CurrentDevicePowerState;

        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisDevicePowerDown: Miniport %p, going to device power state 0x%x\n", Miniport, Miniport->CurrentDevicePowerState));

        //
        //  What type of miniport was this?
        //
        if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_ENABLE))
        {
            //
            //  Set the miniport's device state.
            //
            NdisStatus = ndisQuerySetMiniportDeviceState(Miniport,
                                                         PowerState.DeviceState,
                                                         OID_PNP_SET_POWER,
                                                         TRUE);
        }
        else
        {
            NdisStatus = ndisPmInitializeMiniport(Miniport);
        }

        //
        //  Is the miniport initialized?
        //
        if (NDIS_STATUS_SUCCESS != NdisStatus)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisDevicePowerDown: Miniport %p, failed to power down but we are not able to reinitialize it.\n", Miniport));

            //
            //  Mark the miniport as having failed so that we remove it correctly.
            //
            MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_DEVICE_FAILED);

            //
            //  The bus driver failed the power off and we can't power the miniport back on.
            //  we invalidate the device state so that it will get removed.
            //
            IoInvalidateDeviceState(Miniport->PhysicalDeviceObject);

            pirp->IoStatus.Status = STATUS_UNSUCCESSFUL;
        }
        else
        {
            //
            //  Restore the handlers.
            //
            NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
            ndisMRestoreOpenHandlers(Miniport, fMINIPORT_STATE_PM_STOPPED);
            NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

            IoSetDeviceInterfaceState(&Miniport->SymbolicLinkName, TRUE);


            ndisNotifyDevicePowerStateChange(Miniport, PowerState.DeviceState);
            
            //
            //  Notify the transports.
            //
            NdisStatus = ndisPnPNotifyAllTransports(Miniport,
                                                    NetEventSetPower,
                                                    &PowerState.DeviceState,
                                                    sizeof(PowerState.DeviceState));
            ASSERT(NDIS_STATUS_SUCCESS == NdisStatus);
        }
    }

    PoStartNextPowerIrp(pirp);
    IoCompleteRequest(pirp, 0);

    FREE_POOL(pWorkItem);

    ASSERT(KeGetCurrentIrql() == 0);

    PnPDereferencePackage();
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisDevicePowerDown: Miniport %p\n", Miniport));
}

NTSTATUS
ndisSetDevicePowerDownComplete(
    IN  PDEVICE_OBJECT  pdo,
    IN  PIRP            pirp,
    IN  PVOID           pContext
    )
/*++

Routine Description:


Arguments:

    pdo     -   Pointer to the device object for the miniport.
    pirp    -   Pointer to the device set power state IRP that was completed.
    Context -   Not used

Return Value:

--*/
{
    PNDIS_MINIPORT_BLOCK    Miniport = (PNDIS_MINIPORT_BLOCK)pContext;
    PPOWER_WORK_ITEM        pWorkItem;
#ifdef NDIS_MEDIA_DISCONNECT_POWER_OFF
    BOOLEAN                 fTimerCancelled;
#endif

    UNREFERENCED_PARAMETER(pdo);

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisSetDevicePowerDownComplete: Miniport %p, Irp %p, Status %lx\n",
            Miniport, pirp, pirp->IoStatus.Status));

#ifdef NDIS_MEDIA_DISCONNECT_POWER_OFF
    //
    // cancel any pending media disconnect timers
    //
    if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_WAIT))
    {
        //
        //  Clear the disconnect wait bit and cancel the timer.
        //  IF the timer routine hasn't grabed the lock then we are ok.
        //
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisSetDevicePowerDownComplete: Miniport %p, cancelling media disconnect timer\n",Miniport));
        MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_WAIT);
        MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_MEDIA_DISCONNECT_CANCELLED);

        NdisCancelTimer(&Miniport->MediaDisconnectTimer, &fTimerCancelled);
    }
#endif

    do
    {
        pWorkItem = ALLOC_FROM_POOL(sizeof(POWER_WORK_ITEM), NDIS_TAG_WORK_ITEM);
        if (pWorkItem == NULL)
        {
            pirp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;

            PoStartNextPowerIrp(pirp);
            IoCompleteRequest(pirp, 0);
            break;
        }

        NdisInitializeWorkItem(&pWorkItem->WorkItem,
                               (NDIS_PROC)ndisDevicePowerDown,
                               Miniport);
        pWorkItem->pIrp = pirp;

        //
        //  Schedule the workitem to fire.
        //
        NdisScheduleWorkItem(&pWorkItem->WorkItem);
    } while (FALSE);
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisSetDevicePowerDownComplete: Miniport %p\n", Miniport));

    return(STATUS_MORE_PROCESSING_REQUIRED);
}

NTSTATUS
ndisSetPower(
    IN  PIRP                    pirp,
    IN  PIO_STACK_LOCATION      pirpSp,
    IN  PNDIS_MINIPORT_BLOCK    Miniport
    )
/*++

Routine Description:

    This routine will process the IRP_MN_SET_POWER for a miniport driver.

Arguments:

    pirp        -   Pointer to the IRP.
    pirpSp      -   Pointer to the IRPs current stack location.
    Miniport    -   Pointer to the Miniport

Return Value:

--*/
{
    POWER_STATE             PowerState;
    DEVICE_POWER_STATE      DeviceState;
    SYSTEM_POWER_STATE      SystemState;
    NDIS_DEVICE_POWER_STATE NdisDeviceState;
    NTSTATUS                Status = STATUS_SUCCESS;
    PIO_STACK_LOCATION      pirpSpN;
    IO_STATUS_BLOCK         IoStatus;
    NDIS_STATUS             NdisStatus;
    PIRP                    pIrpWaitWake;
    KIRQL                   OldIrql;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisSetPower: Miniport %p, Irp %p\n", Miniport, pirp));

    PnPReferencePackage();
    
    switch (pirpSp->Parameters.Power.Type)
    {
        case SystemPowerState:

            SystemState = pirpSp->Parameters.Power.State.SystemState;
            Miniport->WaitWakeSystemState = SystemState;
            
            //
            // if system is shutting down, call the shutdown handler
            // for miniport and be done with it
            //

            if (SystemState >= PowerSystemShutdown)
            {
                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                    ("ndisSetPower: Miniport %p, SystemState %lx\n", Miniport, SystemState));

                if ((Miniport->DriverHandle->Flags & fMINIBLOCK_INTERMEDIATE_DRIVER) == 0)
                {
                    ndisMShutdownMiniport(Miniport);
                }

                pirp->IoStatus.Status = STATUS_SUCCESS;
                PoStartNextPowerIrp(pirp);
                IoSkipCurrentIrpStackLocation(pirp);
                Status = PoCallDriver(Miniport->NextDeviceObject, pirp);
                break;
            }
            else
            {
                //
                // Get the device state for the system state. Note that this will
                // set the fMINIPORT_SYSTEM_SLEEPING flag if we are going to 
                // SystemState > PowerSystemWorking
                //
                Status = ndisMPowerPolicy(Miniport, SystemState, &DeviceState, FALSE);

                //
                //  Is the device already powered off?
                //
                if (STATUS_DEVICE_POWERED_OFF == Status)
                {
                    pirp->IoStatus.Status = STATUS_SUCCESS;
            
                    PoStartNextPowerIrp(pirp);
                    IoCompleteRequest(pirp, 0);
                    Status = STATUS_SUCCESS;
                    break;
                }

                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                    ("ndisSetPower: Miniport %p, SystemPowerState[0x%x] DevicePowerState[0x%x]\n", 
                            Miniport, SystemState, DeviceState));

                PowerState.DeviceState = DeviceState;

                if (SystemState > PowerSystemWorking)
                {
                    NdisResetEvent(&Miniport->OpenReadyEvent);

                    //
                    // if system is going to sleep mode, then notify protocols and
                    // request a WAIT_WAKE IRP
                    //
                    
                    //
                    //  Notify the transports of the impending state transition.
                    //  There is nothing we can do if transports fail this
                    //  Note: for all practical purposes there is no need to map
                    //  SytemState to device state here
                    //

                    if (SystemState > PowerSystemSleeping3)
                        NdisDeviceState = PowerSystemSleeping3;
                    else
                        NdisDeviceState = SystemState;

                    ndisNotifyDevicePowerStateChange(Miniport, NdisDeviceState);
                    
                    NdisStatus = ndisPnPNotifyAllTransports(Miniport,
                                                            NetEventSetPower,
                                                            &NdisDeviceState,
                                                            sizeof(SystemState));


                    //
                    // protocols can't fail going to a sleeping state
                    //
                    ASSERT(NDIS_STATUS_SUCCESS == NdisStatus);

                    MiniportReferencePackage();
        
                    //
                    //  Swap the handlers.
                    //
                    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
                    
                    ndisMSwapOpenHandlers(Miniport,
                                          NDIS_STATUS_ADAPTER_NOT_READY,
                                          fMINIPORT_STATE_PM_STOPPED);
                    
                    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
                    MiniportDereferencePackage();
                    
                    //
                    //  What type of miniport was this?
                    //
                    if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_ENABLE))
                    {

                        NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
                        if (Miniport->pIrpWaitWake != NULL)
                        {
                            MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_SEND_WAIT_WAKE);
                        }
                        NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

                        //
                        //  Is wake-up enabled?
                        //
                        if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_SEND_WAIT_WAKE))
                        {
                            MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_SEND_WAIT_WAKE);
                        
                            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                                ("ndisSetPower: Miniport %p, Creating a wake irp for the device\n", Miniport));

                            //
                            // reuquest a power irp for wake notification
                            //
                            PowerState.SystemState = Miniport->WaitWakeSystemState;
                            Status = PoRequestPowerIrp(Miniport->PhysicalDeviceObject,
                                                       IRP_MN_WAIT_WAKE,
                                                       PowerState,
                                                       ndisWaitWakeComplete,
                                                       Miniport,
                                                       &Miniport->pIrpWaitWake);
                                        
                            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                                ("ndisSetPower: Miniport %p, WaiteWakeIrp %p\n",
                                Miniport, Miniport->pIrpWaitWake));
                        }
                    }
                }
                else
                {
                    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
                    pIrpWaitWake = Miniport->pIrpWaitWake;
                    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
                    
                    //
                    // if we are transitioning to PowerSystemWorking or just asserting
                    // it to cancel a query power, we will notify the protocols when
                    // we get the device power IRP
                    //

                    //
                    //  If there is a wait-wake irp outstanding then we need to cancel it.
                    //
                    if (pIrpWaitWake)
                    {
                        if (IoCancelIrp(pIrpWaitWake))
                        {
                            Miniport->pIrpWaitWake = NULL;
                            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                                ("ndisSetPower: Miniport %p, Successfully canceled wake irp\n", Miniport));
                        }
                    }

                    //
                    // Send the S0 irp down the stack first. When it completes, send the D0 irp. This
                    // allows the power manager to resume faster while the slow network initialization
                    // takes place in the background.
                    //
                    IoCopyCurrentIrpStackLocationToNext(pirp);
                    IoSetCompletionRoutine(pirp,
                                           ndisSetSystemPowerOnComplete,
                                           Miniport,
                                           TRUE,
                                           TRUE,
                                           TRUE);
                    IoMarkIrpPending(pirp);
                    PoCallDriver(Miniport->NextDeviceObject, pirp);
                    Status = STATUS_PENDING;
                    break;
                }
            }
            
            //
            // no matter what was the outcome of trying to set a WAIT_WAKE IRP
            // we still have to set the device state appropiately
            // 
            PowerState.DeviceState = DeviceState;
            
            //
            //  Save the device object with the system irp to use in the
            //  completion routine.
            //
            pirpSpN = IoGetNextIrpStackLocation(pirp);
            pirpSpN->DeviceObject = Miniport->DeviceObject;
            IoMarkIrpPending(pirp);

            //
            //  Let the completion routine take care of everything.
            //
            Status = PoRequestPowerIrp(Miniport->PhysicalDeviceObject,
                                       IRP_MN_SET_POWER,
                                       PowerState,
                                       ndisRequestedDevicePowerIrpComplete,
                                       pirp,
                                       NULL);
            if (STATUS_PENDING != Status)
            {
                IoStatus.Status = Status;
                IoStatus.Information = 0;

                ndisRequestedDevicePowerIrpComplete(Miniport->PhysicalDeviceObject,
                                                    IRP_MN_SET_POWER,
                                                    PowerState,
                                                    pirp,
                                                    &IoStatus);
            }
            Status = STATUS_PENDING;
            break;

        case DevicePowerState:

            //
            //  Get the device state.
            //
            DeviceState = pirpSp->Parameters.Power.State.DeviceState;

            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisSetPower: Miniport %p, DeviceState[0x%x]\n", Miniport, DeviceState));

            //
            //  What state is the device going to?
            //
            switch (DeviceState)
            {
                case PowerDeviceD0:
                    //
                    //  We need to pass this IRP down to the pdo so that
                    //  it can power on.
                    //
                    IoCopyCurrentIrpStackLocationToNext(pirp);

                    IoSetCompletionRoutine(pirp,
                                           ndisSetDevicePowerOnComplete,
                                           Miniport,
                                           TRUE,
                                           TRUE,
                                           TRUE);

                    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                        ("ndisSetPower: Miniport %p, Power up the bus driver.\n", Miniport));

                    //
                    //  Mark the IRP as pending and send it down the stack.
                    //
                    IoMarkIrpPending(pirp);
                    PoCallDriver(Miniport->NextDeviceObject, pirp);
                    Status = STATUS_PENDING;
                    break;

                case PowerDeviceD1:
                case PowerDeviceD2:
                case PowerDeviceD3:

                    if (ndisIsMiniportStarted(Miniport) && 
                        (Miniport->PnPDeviceState == NdisPnPDeviceStarted))
                    {
                        //
                        // if the device state setting is not the result of going to
                        // a sleeping system state, (such as media disconnect case)
                        // then notify protocols, etc.
                        //

                        if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_SYSTEM_SLEEPING))
                        {
                            NdisResetEvent(&Miniport->OpenReadyEvent);
                    
                            ndisNotifyDevicePowerStateChange(Miniport, DeviceState);
                            //
                            //  Notify the transports of the impending state transition.
                            //
                            NdisStatus = ndisPnPNotifyAllTransports(Miniport,
                                                                    NetEventSetPower,
                                                                    &DeviceState,
                                                                    sizeof(DeviceState));
                    
                            ASSERT(NDIS_STATUS_SUCCESS == NdisStatus);

                            //
                            //  Swap the handlers.
                            //
                            NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
                            
                            ndisMSwapOpenHandlers(Miniport,
                                                  NDIS_STATUS_ADAPTER_NOT_READY,
                                                  fMINIPORT_STATE_PM_STOPPED);
                            
                            NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
                        }
                            
                        //
                        //  What type of miniport was this?
                        //
                        if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_ENABLE))
                        {
                            BOOLEAN Canceled;
                            
                            if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_SYSTEM_SLEEPING))
                            {
                                NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
                                if (Miniport->pIrpWaitWake != NULL)
                                {
                                    MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_SEND_WAIT_WAKE);
                                }
                                NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

                                //
                                //  Is wake-up enabled?
                                //
                                if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_SEND_WAIT_WAKE))
                                {
                                    MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_SEND_WAIT_WAKE);
                                
                                    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                                        ("ndisSetPower: Miniport %p, Creating a wake irp for the device\n", Miniport));

                                    //
                                    // reuquest a power irp for wake notification
                                    //
                                    PowerState.SystemState = Miniport->WaitWakeSystemState;
                                    
                                    Status = PoRequestPowerIrp(Miniport->PhysicalDeviceObject,
                                                               IRP_MN_WAIT_WAKE,
                                                               PowerState,
                                                               ndisWaitWakeComplete,
                                                               Miniport,
                                                               &Miniport->pIrpWaitWake);
                                                
                                    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                                        ("ndisSetPower: Miniport %p, WaiteWakeIrp %p\n",
                                            Miniport, Miniport->pIrpWaitWake));
                                }
                            }

                            //
                            // disable the interface
                            //
                            if (Miniport->SymbolicLinkName.Buffer != NULL)
                            {
                                IoSetDeviceInterfaceState(&Miniport->SymbolicLinkName, FALSE);
                            }
                            
                            //
                            //  Set the miniport device state.
                            //
                            NdisStatus = ndisQuerySetMiniportDeviceState(Miniport,
                                                                         DeviceState,
                                                                         OID_PNP_SET_POWER,
                                                                         TRUE);
                            if (NDIS_STATUS_SUCCESS != NdisStatus)
                            {
                                //1 we are not allowed to fail a set power
                                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                                    ("ndisSetPower: Miniport %p, Failed to power the device down\n", Miniport));
                                
                                if (Miniport->SymbolicLinkName.Buffer != NULL)
                                {
                                    IoSetDeviceInterfaceState(&Miniport->SymbolicLinkName, TRUE);
                                }
                
                                pirp->IoStatus.Status = NdisStatus;
                        
                                PoStartNextPowerIrp(pirp);
                                IoCompleteRequest(pirp, 0);
                                Status = NdisStatus;
                                break;
                            }
                            
                            NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
                            if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_CANCEL_WAKE_UP_TIMER))
                            {
                                KEVENT          RequestsCompletedEvent;

                                MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_CANCEL_WAKE_UP_TIMER);
                                                                
                                NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
                                
                                NdisCancelTimer(&Miniport->WakeUpDpcTimer, &Canceled);
                                
                                if (!Canceled)
                                {
                                    INITIALIZE_EVENT(&RequestsCompletedEvent);
                                    Miniport->WakeUpTimerEvent = &RequestsCompletedEvent;
                                }
                                
                                if (Miniport->WakeUpTimerEvent)
                                {
                                    WAIT_FOR_OBJECT(&RequestsCompletedEvent, NULL);
                                }
                                Miniport->WakeUpTimerEvent = NULL;
                            }
                            else
                            {
                                NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
                            }

                        }
                        else
                        {
                            if ((Miniport->DriverHandle->Flags & fMINIBLOCK_INTERMEDIATE_DRIVER) == 0)
                            {
                                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                                    ("ndisSetPower: Miniport %p, Halt the miniport\n", Miniport));

                                if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_FAILED))
                                {
                                    //
                                    //  Halt the legacy miniport.
                                    //
                                    ndisPmHaltMiniport(Miniport);
                                }
                            }
                        }
                    }
                    
                    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                        ("ndisSetPower: Miniport %p, Notify the bus driver of the low power state\n", Miniport));

                    //
                    //  We need to pass this IRP down to the pdo so that
                    //  it can power down.
                    //
                    IoCopyCurrentIrpStackLocationToNext(pirp);

                    IoSetCompletionRoutine(pirp,
                                           ndisSetDevicePowerDownComplete,
                                           Miniport,
                                           TRUE,
                                           TRUE,
                                           TRUE);

                    IoMarkIrpPending(pirp);
                    PoCallDriver(Miniport->NextDeviceObject, pirp);
                    Status = STATUS_PENDING;
                    break;
            }

            //
            //  Done with processing the device set power state.
            //
            break;
    }
    
    PnPDereferencePackage();

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisSetPower: Miniport %p, Status %lx\n", Miniport, Status));

    return(Status);
}


NTSTATUS
ndisPowerDispatch(
    IN  PDEVICE_OBJECT          pDeviceObject,
    IN  PIRP                    pirp
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    PIO_STACK_LOCATION      pirpSp;
    NTSTATUS                Status;
    PNDIS_MINIPORT_BLOCK    Miniport;
    PDEVICE_OBJECT          NextDeviceObject;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisPowerDispatch: DeviceObject %p, Irp %p\n", pDeviceObject, pirp));

    PnPReferencePackage();

    //
    //  Get a pointer to the adapter block and miniport block then determine
    //  which one we should use.
    //
    Miniport = (PNDIS_MINIPORT_BLOCK)((PNDIS_WRAPPER_CONTEXT)pDeviceObject->DeviceExtension + 1);
    
    if (Miniport->Signature != (PVOID)MINIPORT_DEVICE_MAGIC_VALUE)
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisPowerDispatch: DeviceObject %p, Irp %p, Device extension is not a miniport.\n", pDeviceObject, pirp));
        //
        //  Fail the invalid request.
        //
        pirp->IoStatus.Status = Status = STATUS_INVALID_DEVICE_REQUEST;
        PoStartNextPowerIrp(pirp);
        IoCompleteRequest(pirp, 0);
        goto Done;
    }
    
    //
    //  Get a pointer to the next DeviceObject.
    //
    NextDeviceObject = Miniport->NextDeviceObject;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("ndisPowerDispatch: Miniport %p\n", Miniport));

    //
    //  Get the stack parameters for this IRP.
    //
    pirpSp = IoGetCurrentIrpStackLocation(pirp);

    switch (pirpSp->MinorFunction)
    {
        //
        // power management stuff
        //
        case IRP_MN_POWER_SEQUENCE:

            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisPowerDispatch: Miniport %p, Processing IRP_MN_POWER_SEQUENCE\n", Miniport));
            
            //
            //  Generic routine that will pass the IRP to the next device
            //  object in the layer that wants to process it.
            //
            IoCopyCurrentIrpStackLocationToNext(pirp);
            Status = ndisPassIrpDownTheStack(pirp, NextDeviceObject);
            pirp->IoStatus.Status = Status;
            IoCompleteRequest(pirp, 0);
            break;

        case IRP_MN_WAIT_WAKE:

            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisPowerDispatch: Miniport %p, Processing IRP_MN_WAIT_WAKE\n", Miniport));

            //
            //  Fill in the wake information.
            //
            pirpSp->Parameters.WaitWake.PowerState = Miniport->WaitWakeSystemState;
            IoCopyCurrentIrpStackLocationToNext(pirp);
            Status = PoCallDriver(NextDeviceObject, pirp);
            break;

        case IRP_MN_QUERY_POWER:

            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisPowerDispatch: Miniport %p, Processing IRP_MN_QUERY_POWER\n", Miniport));

            Status = ndisQueryPower(pirp, pirpSp, Miniport);
            break;

        case IRP_MN_SET_POWER:

            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisPowerDispatch: Miniport %p, Processing IRP_MN_SET_POWER\n", Miniport));

            Status = ndisSetPower(pirp, pirpSp, Miniport);
            break;

        default:
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisPowerDispatch: Miniport %p, Processing minor function: %lx\n",
                Miniport, pirpSp->MinorFunction));

            //
            // send the IRP down
            //
            PoStartNextPowerIrp(pirp);
            IoSkipCurrentIrpStackLocation(pirp);
            Status = PoCallDriver(NextDeviceObject, pirp);
            break;          
    }

Done:
    PnPDereferencePackage();
    
    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisPowerDispatch: Miniport %p, Status 0x%x\n", Miniport, Status));

    return(Status);
}


NTSTATUS
FASTCALL
ndisMShutdownMiniport(
    IN  PNDIS_MINIPORT_BLOCK    Miniport
    )

/*++

Routine Description:

    The "shutdown handler" for the SHUTDOWN Irp.  Will call the Ndis
    shutdown routine, if one is registered.

Arguments:

    DeviceObject - The adapter's device object.
    Irp - The IRP.

Return Value:

    Always STATUS_SUCCESS.

--*/

{
    PDEVICE_OBJECT          DeviceObject = Miniport->DeviceObject;
    PNDIS_WRAPPER_CONTEXT   WrapperContext =  (PNDIS_WRAPPER_CONTEXT)DeviceObject->DeviceExtension;
    KIRQL                   OldIrql;

    DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("==>ndisMShutdownMiniport: Miniport %p\n", Miniport));

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);

    //
    //  Mark the miniport as halting and NOT using normal interrupts.
    //
    MINIPORT_SET_FLAG(Miniport, fMINIPORT_PM_HALTING);
    MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_SHUTTING_DOWN);
    MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_NORMAL_INTERRUPTS);

    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

    if ((WrapperContext->ShutdownHandler != NULL) &&
        (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_NO_SHUTDOWN) == 0))
    {
        //
        // Call the shutdown routine.
        //
        if (WrapperContext->ShutdownHandler != NULL)
        {
            WrapperContext->ShutdownHandler(WrapperContext->ShutdownContext);
            MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_SHUT_DOWN);
        }
    }

    DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("<==ndisMShutdownMiniport: Miniport %p\n", Miniport));

    return STATUS_SUCCESS;
}


NTSTATUS
ndisMPowerPolicy(
    IN  PNDIS_MINIPORT_BLOCK    Miniport,
    IN  SYSTEM_POWER_STATE      SystemState,
    IN  PDEVICE_POWER_STATE     pDeviceState,
    IN  BOOLEAN                 fIsQuery
    )
/*++

Routine Description:

    This routine will determine if the miniport should go to the given device state.

Arguments:      

    Miniport    -   Pointer to the miniport block
    SystemState -   State the system wants to go to.

Return Value:

--*/
{
    DEVICE_POWER_STATE              DeviceStateForSystemState, MinDeviceWakeup = PowerDeviceUnspecified;
    NTSTATUS                        Status = STATUS_SUCCESS;
    DEVICE_POWER_STATE              NewDeviceState = PowerDeviceD3;
    PNDIS_PM_WAKE_UP_CAPABILITIES   pWakeCaps;
    NDIS_STATUS                     NdisStatus;
    ULONG                           WakeEnable;
    PIRP                            pIrpWaitWake;
    KIRQL                           OldIrql;
    BOOLEAN                         fDone = FALSE;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("==>ndisMPowerPolicy: Miniport %p, SystemState %lx\n", Miniport, SystemState));


    if (SystemState >= PowerSystemShutdown)
    {
        //
        // if this is a shutdown request, set device to D3 and return
        //
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisMPowerPolicy: Miniport %p, shutting down\n", Miniport));

        *pDeviceState = PowerDeviceD3;
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("<==ndisMPowerPolicy: Miniport %p\n", Miniport));
        return(STATUS_SUCCESS);
    }
    
    //
    //  If the system wants to transition to working then we are going to D0. 
    //
    if (SystemState == PowerSystemWorking)
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisMPowerPolicy: Miniport %p, Wakeing up the device\n", Miniport));
            
        if (!fIsQuery)
        {
            MINIPORT_PNP_CLEAR_FLAG(Miniport, fMINIPORT_SYSTEM_SLEEPING);
        }

        *pDeviceState = PowerDeviceD0;
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("<==ndisMPowerPolicy: Miniport %p\n", Miniport));
        return(STATUS_SUCCESS);
    }
    
    if (!fIsQuery)
    {
        //
        // tag the miniport so when we get the device power IRP, we
        // know we have already been here, taken care of protocols, etc.
        //
        MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_SYSTEM_SLEEPING);
    }
    
    //
    //  if this is a legacy miniport or power-disabled miniport then throw it in D3
    //  do the same thing for IM miniports that have not been initialized yet 
    //
    if ((!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_ENABLE)) ||
        (!(ndisIsMiniportStarted(Miniport) && (Miniport->PnPDeviceState == NdisPnPDeviceStarted))))
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisMPowerPolicy: Miniport %p, Place legacy or PM disabled device in D3\n", Miniport));

        *pDeviceState = PowerDeviceD3;
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("<==ndisMPowerPolicy: Miniport %p\n", Miniport));
        return(STATUS_SUCCESS);
    }

    //
    //  First check for the case where the netcard is already asleep due to a 
    //  media disconnect.
    //
    
    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
    pIrpWaitWake = Miniport->pIrpWaitWake;
    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

    if (Miniport->CurrentDevicePowerState > PowerDeviceD0)
    {

        if (pIrpWaitWake != NULL)
        {
            ///
            //  Miniport is in a lower power state than D0 and there is a wake irp pending in
            //  the bus driver. This is a pretty good indication that the cable was pulled.
            //  We are not going to enable any wake-up method seeing as the cable has been disconnect.
            //  but if the user does not want to wakeup the machine as a result of a cable
            // reconnect, cancel any pending wait-wake IRP
            ///

            if (!fIsQuery && ((!MINIPORT_PNP_TEST_FLAG (Miniport, fMINIPORT_DEVICE_POWER_WAKE_ENABLE)) ||
                             (Miniport->PnPCapabilities & NDIS_DEVICE_DISABLE_WAKE_ON_RECONNECT)))
            {
                if (IoCancelIrp(pIrpWaitWake))
                {
                    Miniport->pIrpWaitWake = NULL;
                    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                        ("ndisMPowerPolicy: Miniport %p, Successfully canceled media connect wake irp\n", Miniport));
                }
            }
        }
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("<==ndisMPowerPolicy: Miniport %p\n", Miniport));
        return(STATUS_DEVICE_POWERED_OFF);
    }

    do
    {
        //
        //  Is system wake-up enabled in the policy?
        //  if wake-up is not enabled then we simply power off.
        //
        if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_WAKE_ENABLE))
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisMPowerPolicy: Miniport %p, Device power wake is not enabled (%u)\n",
                    Miniport, MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_WAKE_ENABLE)));

            break;
        }


        //
        //  This is the -lightest- state the device can go to for the requested
        //  system state. 
        //
        DeviceStateForSystemState = Miniport->DeviceCaps.DeviceState[SystemState];

        //
        //  Check to see if we are going below SystemSleeping3
        //
        //
        //
        // if we are going to S4 or deeper and device can not wake up the system from that state
        // just do it
        //
        if ((SystemState >= PowerSystemHibernate) && 
            ((SystemState > Miniport->DeviceCaps.SystemWake) || (DeviceStateForSystemState > Miniport->DeviceCaps.DeviceWake)))
        {

            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisMPowerPolicy: Miniport %p, System is either entering hibernate or shutting down.\n", Miniport));

            //
            //  We succeed this call.
            //
            break;
        } 

        //
        //  Get a nice pointer to the wake-up capabilities.
        //
        pWakeCaps = &Miniport->PMCapabilities.WakeUpCapabilities;

        if ((NDIS_PNP_WAKE_UP_MAGIC_PACKET == (Miniport->WakeUpEnable & NDIS_PNP_WAKE_UP_MAGIC_PACKET)) &&
            (PowerDeviceUnspecified != pWakeCaps->MinMagicPacketWakeUp))
        {
            MinDeviceWakeup = pWakeCaps->MinMagicPacketWakeUp;
        }

        if ((NDIS_PNP_WAKE_UP_PATTERN_MATCH == (Miniport->WakeUpEnable & NDIS_PNP_WAKE_UP_PATTERN_MATCH)) &&
            (PowerDeviceUnspecified != pWakeCaps->MinPatternWakeUp))
        {
            if ((MinDeviceWakeup == PowerDeviceUnspecified) || 
                (MinDeviceWakeup > pWakeCaps->MinPatternWakeUp)) 
            {
                    MinDeviceWakeup = pWakeCaps->MinPatternWakeUp;
            }
        }

        //
        // if both MagicPacket and pattern match are NOT enabled (or the system can't do either)
        // then we may as well go to D3.
        //
        if (MinDeviceWakeup == PowerDeviceUnspecified)
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
                ("ndisMPowerPolicy: Miniport %p, MagicPacket and pattern match are not enabled.\n", Miniport));

            break;
        }

        //
        // from this point on, we try to go to power state that we can wake up the system from
        //

        //
        // make sure we don't go too deep
        //

        if (MinDeviceWakeup > Miniport->DeviceCaps.DeviceWake)
        {
            MinDeviceWakeup = Miniport->DeviceCaps.DeviceWake;
        }
        
        //
        //  If the system state requested is lower than the minimum required to wake up the system 
        //  or the corresponding device state is deeper than the lowest device state to wake 
        //  up the system then we
        //  fail this call. Note that we also set the device state to D3. Since
        //  we are not going to be able to support wake-up then we power off.
        //  The query power will look at the failure code and return that to the
        //  system. The set power will ignore the failure code and set the device
        //  into D3.
        //
        if ((SystemState > Miniport->DeviceCaps.SystemWake) ||
            (DeviceStateForSystemState > MinDeviceWakeup) ||
            (DeviceStateForSystemState == PowerDeviceUnspecified))
        {
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                ("ndisMPowerPolicy: Miniport %p, Requested system state is lower than the minimum wake-up system state\n", Miniport));

            Status = STATUS_UNSUCCESSFUL;
            break;
        }

        //
        // starting from DeviceWake and up to DeviceState[SystemState], find a
        // suitable device state
        //
        switch (MinDeviceWakeup)
        {
          case PowerDeviceD3:
            if (Miniport->DeviceCaps.WakeFromD3)
            {
                NewDeviceState =  PowerDeviceD3;
                break;
            }
          case PowerDeviceD2:
            if (Miniport->DeviceCaps.DeviceD2 && Miniport->DeviceCaps.WakeFromD2)
            {
              NewDeviceState =  PowerDeviceD2;
              break;
            }
          case PowerDeviceD1:
            if (Miniport->DeviceCaps.DeviceD1 && Miniport->DeviceCaps.WakeFromD1)
            {
              NewDeviceState =  PowerDeviceD1;
              break;
            }
          case PowerDeviceD0:
            if (Miniport->DeviceCaps.WakeFromD0)
            {
              NewDeviceState =  PowerDeviceD0;
              break;
            }
          default:
            Status = STATUS_UNSUCCESSFUL;
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                ("ndisMPowerPolicy: Miniport %p, couldn't find any wake-able DeviceState 0x%x\n", Miniport));
            break;

        }


        //
        // ok, we started with deepest state (based on what device said can do)
        // and went up. make sure we didn't go too far up. i.e. the statem state
        // we are going to can maintain the device in desired power state
        //
        if ((Status == NDIS_STATUS_SUCCESS) &&
            (DeviceStateForSystemState > NewDeviceState))
        {
            Status = STATUS_UNSUCCESSFUL;
            DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                ("ndisMPowerPolicy: Miniport %p, couldn't find any wake-able DeviceState 0x%x\n", Miniport));
        
        }

        //
        //  If this is for the set power then we need to enable wake-up on the miniport.
        //
        if (!fIsQuery)
        {
            //
            //  We need to send a request to the miniport to enable the correct wake-up types NOT 
            //  including the link change.
            //
            WakeEnable = Miniport->WakeUpEnable & ~NDIS_PNP_WAKE_UP_LINK_CHANGE;
            
            if (Miniport->PnPCapabilities & NDIS_DEVICE_DISABLE_WAKE_ON_PATTERN_MATCH)
            {
                WakeEnable &= ~NDIS_PNP_WAKE_UP_PATTERN_MATCH;
            }

            if (Miniport->PnPCapabilities & NDIS_DEVICE_DISABLE_WAKE_ON_MAGIC_PACKET)
            {
                WakeEnable &= ~NDIS_PNP_WAKE_UP_MAGIC_PACKET;
            }
    
            NdisStatus = ndisQuerySetMiniportDeviceState(Miniport,
                                                         WakeEnable,
                                                         OID_PNP_ENABLE_WAKE_UP,
                                                         TRUE);

            if (NDIS_STATUS_SUCCESS == NdisStatus)
            {
                MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_SEND_WAIT_WAKE);
            }
            else
            {
                DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_ERR,
                    ("ndisMPowerPolicy: Miniport %p, Unable to enable the following wake-up methods 0x%x\n", Miniport, WakeEnable));
    
                //
                //  Since we can't enable the wake methods we may as well go to D3.
                //
                NewDeviceState = PowerDeviceD3;
                break;
            }
        }

        //
        //  Save the device state that we should go to.
        //
        *pDeviceState = NewDeviceState;
    
        fDone = TRUE;
        
    } while (FALSE);

    if (fDone)
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisMPowerPolicy: Miniport %p, SystemState 0x%x, DeviceState 0x%x\n", Miniport, SystemState, *pDeviceState));
    
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("<==ndisMPowerPolicy: Miniport %p\n", Miniport));
    
        return(Status);
    }

    //
    //  If this is not a query then we need to cancel wake-up on the miniport.
    //
    if (!fIsQuery && MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_DEVICE_POWER_WAKE_ENABLE))
    {
        DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
            ("ndisMPowerPolicy: Miniport %p, Disabling wake-up on the miniport\n", Miniport));

        WakeEnable = 0;
    
        ndisQuerySetMiniportDeviceState(Miniport,
                                        WakeEnable,
                                        OID_PNP_ENABLE_WAKE_UP,
                                        TRUE);
    }

    //
    //  Save the device state that we should go to.
    //
    *pDeviceState = NewDeviceState;

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("ndisMPowerPolicy: Miniport %p, SystemState 0x%x, DeviceState 0x%x\n", Miniport, SystemState, *pDeviceState));

    DBGPRINT_RAW(DBG_COMP_PM, DBG_LEVEL_INFO,
        ("<==ndisMPowerPolicy: Miniport %p\n", Miniport));

    return(Status);
}