ul_wdpwr.c

linux下的RS485的驱动 值得一看

/*******************************************************************
  uLan Communication - uL_DRV - multiplatform uLan driver

  ul_wdpwr.c	- Windows WDM PWR events processing code

  (C) Copyright 1996-2004 by Pavel Pisa - project originator
        http://cmp.felk.cvut.cz/~pisa
  (C) Copyright 1996-2004 PiKRON Ltd.
        http://www.pikron.com
  (C) Copyright 2002-2004 Petr Smolik
  

  The uLan driver project can be used and distributed 
  in compliance with any of next licenses
   - GPL - GNU Public License
     See file COPYING for details.
   - LGPL - Lesser GNU Public License
   - MPL - Mozilla Public License
   - and other licenses added by project originator

  Code can be modified and re-distributed under any combination
  of the above listed licenses. If contributor does not agree with
  some of the licenses, he/she can delete appropriate line.
  WARNING: if you delete all lines, you are not allowed to
  distribute code or sources in any form.
 *******************************************************************/

NTSTATUS
DispatchPower(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*++

Routine Description:

    This is our FDO's dispatch table function for IRP_MJ_POWER.
    It processes the Power IRPs sent to the PDO for this device.

    For every power IRP, drivers must call PoStartNextPowerIrp and use PoCallDriver
    to pass the IRP all the way down the driver stack to the underlying PDO.


Arguments:

    DeviceObject - pointer to our device object (FDO)

    Irp          - pointer to an I/O Request Packet

Return Value:

    NT status code

--*/
{
    PIO_STACK_LOCATION ioStackLocation;
    NTSTATUS code = STATUS_SUCCESS;
    PULAN_DEVICE_EXTENSION deviceExtension;
    BOOLEAN fGoingToD0 = FALSE;
    POWER_STATE sysPowerState, desiredDevicePowerState;
    KEVENT event;

    uLan_DbgPrint("uLan: DispatchPower: called\n");

    //
    // Get a pointer to our (FUNCTIONAL) device object's device
    // extension.
    //
    deviceExtension = (PULAN_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

    //
    // Up the count of in-progress requests
    //
    RequestIncrement(deviceExtension);

    ioStackLocation = IoGetCurrentIrpStackLocation(Irp);

    switch (ioStackLocation->MinorFunction) {
    case IRP_MN_WAIT_WAKE:
        uLan_DbgPrint("uLan: DispatchPower:  Enter IRP_MN_WAIT_WAKE\n");
 
                // A driver sends IRP_MN_WAIT_WAKE to indicate that the system should
                // wait for its device to signal a wake event. The exact nature of the event
                // is device-dependent.
                // Drivers send this IRP for two reasons:
                // 1) To allow a device to wake the system
                // 2) To wake a device that has been put into a sleep state to save power
                //    but still must be able to communicate with its driver under certain circumstances.
                // When a wake event occurs, the driver completes the IRP and returns
                // STATUS_SUCCESS. If the device is sleeping when the event occurs,
                // the driver must first wake up the device before completing the IRP.
                // In a completion routine, the driver calls PoRequestPowerIrp to send a
                // PowerDeviceD0 request. When the device has powered up, the driver can
                //  handle the IRP_MN_WAIT_WAKE request.

        // deviceExtension->DeviceCapabilities.DeviceWake specifies the lowest device power state (least powered)
        // from which the device can signal a wake event
        deviceExtension->PowerDownLevel = deviceExtension->DeviceCapabilities.DeviceWake;


        if  ( ( PowerDeviceD0 == deviceExtension->CurrentDevicePowerState )  ||
              ( deviceExtension->DeviceCapabilities.DeviceWake > deviceExtension->CurrentDevicePowerState ) ) {
                        //
                        //    STATUS_INVALID_DEVICE_STATE is returned if the device in the PowerD0 state
                        //    or a state below which it can support waking, or if the SystemWake state
                        //    is below a state which can be supported. A pending IRP_MN_WAIT_WAKE will complete
                        //    with this error if the device's state is changed to be incompatible with the wake
                        //    request.

            //  If a driver fails this IRP, it should complete the IRP immediately without
            //  passing the IRP to the next-lower driver.
            code = STATUS_INVALID_DEVICE_STATE;
            Irp->IoStatus.Status = code;
            IoCompleteRequest (Irp,IO_NO_INCREMENT );
            uLan_DbgPrint("uLan: DispatchPower: ntStatus STATUS_INVALID_DEVICE_STATE\n" );
            RequestDecrement(deviceExtension);
            return code; 
        }

        // flag we're enabled for wakeup
        deviceExtension->EnabledForWakeup = TRUE;

        // init an event for our completion routine to signal when PDO is done with this Irp
        KeInitializeEvent(&event, NotificationEvent, FALSE);

       // If not failing outright, pass this on to our PDO for further handling
        IoCopyCurrentIrpStackLocationToNext(Irp);

        // Set a completion routine so it can signal our event when
        //  the PDO is done with the Irp
        IoSetCompletionRoutine(Irp,
                               PnpComplete,
                               &event,  // pass the event to the completion routine as the Context
                               TRUE,    // invoke on success
                               TRUE,    // invoke on error
                               TRUE);   // invoke on cancellation

        PoStartNextPowerIrp(Irp);
        code = PoCallDriver(deviceExtension->DeviceToSendIrpsTo, Irp); 

         // if PDO is not done yet, wait for the event to be set in our completion routine
        if (code == STATUS_PENDING) {
             // wait for irp to complete

            NTSTATUS waitStatus = KeWaitForSingleObject(
                &event,
                Suspended,
                KernelMode,
                FALSE,
                NULL);

            uLan_DbgPrint("uLan: DispatchPower: done waiting for PDO to finish IRP_MN_WAIT_WAKE\n");
        }

        // now tell the device to actually wake up
        SelfSuspendOrActivate( DeviceObject, FALSE );

        // flag we're done with wakeup irp
        deviceExtension->EnabledForWakeup = FALSE;

        RequestDecrement(deviceExtension);
        
        uLan_DbgPrint("uLan: DispatchPower:  Exit IRP_MN_WAIT_WAKE\n");
        break;

    case IRP_MN_SET_POWER:
                // The system power policy manager sends this IRP to set the system power state.
                // A device power policy manager sends this IRP to set the device power state for a device.

        uLan_DbgPrint("uLan: DispatchPower:  Enter IRP_MN_SET_POWER\n");

        // Set Irp->IoStatus.Status to STATUS_SUCCESS to indicate that the device
        // has entered the requested state. Drivers cannot fail this IRP.

        switch (ioStackLocation->Parameters.Power.Type) {
            case SystemPowerState:

                // Get input system power state
                sysPowerState.SystemState = ioStackLocation->Parameters.Power.State.SystemState;

                uLan_DbgPrint("uLan: PM_Power() Set Power, type SystemPowerState = %s\n",
                                SystemPowerStateString[sysPowerState.SystemState]);

                // If system is in working state always set our device to D0
                //  regardless of the wait state or system-to-device state power map
                if ( sysPowerState.SystemState ==  PowerSystemWorking) {
                    desiredDevicePowerState.DeviceState = PowerDeviceD0;

                     uLan_DbgPrint("uLan: ProcessPowerIrp() PowerSystemWorking, will set D0, not use state map\n");


                } else {
                     // set to corresponding system state if IRP_MN_WAIT_WAKE pending
                    if ( deviceExtension->EnabledForWakeup ) { // got a WAIT_WAKE IRP pending?

                        // Find the device power state equivalent to the given system state.
                        // We get this info from the DEVICE_CAPABILITIES struct in our device
                        // extension (initialized in PnPAddDevice() )
                        desiredDevicePowerState.DeviceState =
                            deviceExtension->DeviceCapabilities.DeviceState[ sysPowerState.SystemState ];

                        uLan_DbgPrint("uLan: ProcessPowerIrp() IRP_MN_WAIT_WAKE pending, will use state map\n");

                    } else {
                        // if no wait pending and the system's not in working state, just turn off
                        desiredDevicePowerState.DeviceState = PowerDeviceD3;

                        uLan_DbgPrint("uLan: ProcessPowerIrp() Not EnabledForWakeup and the system's not in working state,\n  settting PowerDeviceD3 (off )\n");
                    }
                }

                //
                // We've determined the desired device state; are we already in this state?
                //

                uLan_DbgPrint("ulan: ProcessPowerIrp()  Set Power, desiredDevicePowerState = %s\n",
                    DevicePowerStateString[desiredDevicePowerState.DeviceState]);

                if (desiredDevicePowerState.DeviceState !=
                    deviceExtension->CurrentDevicePowerState) {

                    //RequestIncrement(deviceExtension);

                    // No, request that we be put into this state
                                        // by requesting a new Power Irp from the Pnp manager
                    deviceExtension->PowerIrp = Irp;
                    code = PoRequestPowerIrp(deviceExtension->DeviceObject,
                                             IRP_MN_SET_POWER,
                                             desiredDevicePowerState,
                                                                                           // completion routine will pass the Irp down to the PDO
                                             PoRequestCompletion,
                                             DeviceObject,
                                             NULL);

                } else {
                    // Yes, just pass it on to PDO (Physical Device Object)
                    IoCopyCurrentIrpStackLocationToNext(Irp);
                    PoStartNextPowerIrp(Irp);
                    code = PoCallDriver(deviceExtension->DeviceToSendIrpsTo, Irp); 

                    RequestDecrement(deviceExtension);

                    uLan_DbgPrint("uLan: DispatchPower:  Exit IRP_MN_SET_POWER\n");

                }
                break;

            case DevicePowerState:

                uLan_DbgPrint("uLan: PM_Power() Set Power, type DevicePowerState = %s\n",
                                DevicePowerStateString[ioStackLocation->Parameters.Power.State.DeviceState]);

                // For requests to D1, D2, or D3 ( sleep or off states ),
                                // sets deviceExtension->CurrentDevicePowerState to DeviceState immediately.
                                // This enables any code checking state to consider us as sleeping or off
                                // already, as this will imminently become our state.

                // For requests to DeviceState D0 ( fully on ), sets fGoingToD0 flag TRUE
                // to flag that we must set a completion routine and update
                                // deviceExtension->CurrentDevicePowerState there.
                                // In the case of powering up to fully on, we really want to make sure
                                // the process is completed before updating our CurrentDevicePowerState,
                                // so no IO will be attempted or accepted before we're really ready.

                fGoingToD0 = SetDevicePowerState(DeviceObject,
                                                 ioStackLocation->Parameters.Power.State.DeviceState
                                                 ); // returns TRUE for D0

                IoCopyCurrentIrpStackLocationToNext(Irp);

                if (fGoingToD0) {
                    uLan_DbgPrint("uLan: DispatchPower: Set PowerIrp Completion Routine, fGoingToD0 =%d\n", fGoingToD0);
                    IoSetCompletionRoutine(Irp,
                           PowerIrp_Complete,
                           // Always pass FDO to completion routine as its Context;
                           // This is because the DriverObject passed by the system to the routine
                           // is the Physical Device Object ( PDO ) not the Functional Device Object ( FDO )
                           DeviceObject,
                           TRUE,            // invoke on success
                           TRUE,            // invoke on error
                           TRUE);           // invoke on cancellation of the Irp
                }

                PoStartNextPowerIrp(Irp);
                code = PoCallDriver(deviceExtension->DeviceToSendIrpsTo, Irp); 

                if ( !fGoingToD0 ) // completion routine will decrement
                    RequestDecrement(deviceExtension);

                uLan_DbgPrint("uLan: DispatchPower:  Exit IRP_MN_SET_POWER\n");
                break;

            } // case irpStack->Parameters.Power.Type 

       break; // IRP_MN_SET_POWER 

    case IRP_MN_QUERY_POWER:
                //
                // A power policy manager sends this IRP to determine whether it can change
                // the system or device power state, typically to go to sleep.
                //

        uLan_DbgPrint("uLan: DispatchPower:  IRP_MN_QUERY_POWER\n");

        IoCopyCurrentIrpStackLocationToNext(Irp);
        PoStartNextPowerIrp(Irp);
        code = PoCallDriver(deviceExtension->DeviceToSendIrpsTo, Irp); 

        RequestDecrement(deviceExtension);

        break; /* IRP_MN_QUERY_POWER */

    default:

        uLan_DbgPrint("uLan: DispatchPower:  UNKNOWN POWER MESSAGE (%x)\n", ioStackLocation->MinorFunction);

        //
        // All unhandled power messages are passed on to the PDO
        //

        IoCopyCurrentIrpStackLocationToNext(Irp);
        PoStartNextPowerIrp(Irp);
        code = PoCallDriver(deviceExtension->DeviceToSendIrpsTo, Irp); 

        RequestDecrement(deviceExtension);


    } /* irpStack->MinorFunction */

    uLan_DbgPrint("uLan: Exit DispatchPower:   ntStatus = 0x%x\n", code);
    return code;
}

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

Routine Description:

        This is the completion routine set in a call to PoRequestPowerIrp()
        that was made in ProcessPowerIrp() in response to receiving
    an IRP_MN_SET_POWER of type 'SystemPowerState' when the device was
        not in a compatible device power state. In this case, a pointer to
        the IRP_MN_SET_POWER Irp is saved into the FDO device extension
        (deviceExtension->PowerIrp), and then a call must be
        made to PoRequestPowerIrp() to put the device into a proper power state,
        and this routine is set as the completion routine.

    We decrement our pending io count and pass the saved IRP_MN_SET_POWER Irp
        on to the next driver

Arguments:

    DeviceObject - Pointer to the device object for the class device.
        Note that we must get our own device object from the Context

    Context - Driver defined context, in this case our own functional device object ( FDO )

Return Value:

    The function value is the final status from the operation.

--*/
{
    PIRP irp;
    PULAN_DEVICE_EXTENSION deviceExtension;
    PDEVICE_OBJECT deviceObject = Context;
    NTSTATUS ntStatus;

    deviceExtension = deviceObject->DeviceExtension;

        // Get the Irp we saved for later processing in ProcessPowerIrp()
        // when we decided to request the Power Irp that this routine
        // is the completion routine for.
    irp = deviceExtension->PowerIrp;

        // We will return the status set by the PDO for the power request we're completing
    ntStatus = IoStatus->Status;

    uLan_DbgPrint("uLan: Enter PoRequestCompletion()\n");

    // we should not be in the midst of handling a self-generated power irp
    ASSERT( !deviceExtension->SelfPowerIrp );

    // we must pass down to the next driver in the stack
    IoCopyCurrentIrpStackLocationToNext(irp);

    // Calling PoStartNextPowerIrp() indicates that the driver is finished
    // with the previous power IRP, if any, and is ready to handle the next power IRP.
    // It must be called for every power IRP.Although power IRPs are completed only once,
    // typically by the lowest-level driver for a device, PoStartNextPowerIrp must be called
    // for every stack location. Drivers must call PoStartNextPowerIrp while the current IRP
    // stack location points to the current driver. Therefore, this routine must be called
    // before IoCompleteRequest, IoSkipCurrentStackLocation, and PoCallDriver.

    PoStartNextPowerIrp(irp);

    // PoCallDriver is used to pass any power IRPs to the PDO instead of IoCallDriver.