power.c File Reference

#include <pci.h>
#include <debug.h>

Include dependency graph for power.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	PciStallForPowerChange (IN PPCI_PDO_EXTENSION PdoExtension, IN DEVICE_POWER_STATE PowerState, IN ULONG_PTR CapOffset)
NTSTATUS NTAPI	PciSetPowerManagedDevicePowerState (IN PPCI_PDO_EXTENSION DeviceExtension, IN DEVICE_POWER_STATE DeviceState, IN BOOLEAN IrpSet)
static VOID NTAPI	PciFdoDevicePowerCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ UCHAR MinorFunction, _In_ POWER_STATE PowerState, _In_opt_ PVOID Context, _In_ PIO_STATUS_BLOCK IoStatus)
	Finishes a system set power request once the bus has been through the device state that request asked for.
static NTSTATUS NTAPI	PciFdoSystemPowerCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)
	Asks for the device state that matches a system set power request once the drivers below the bus have handled it.
NTSTATUS NTAPI	PciFdoWaitWake (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoSetPowerState (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpQueryPower (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)

Variables
ULONG	PciPowerDelayTable [PowerDeviceD3 *PowerDeviceD3]
static REQUEST_POWER_COMPLETE	PciFdoDevicePowerCompletion
static IO_COMPLETION_ROUTINE	PciFdoSystemPowerCompletion

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file power.c.

Function Documentation

PciFdoDevicePowerCompletion()

static VOID NTAPI PciFdoDevicePowerCompletion ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ UCHAR  MinorFunction, _In_ POWER_STATE  PowerState, _In_opt_ PVOID  Context, _In_ PIO_STATUS_BLOCK  IoStatus  )

static

Finishes a system set power request once the bus has been through the device state that request asked for.

Parameters

[in]

Context

The system power IRP that is still held.

Definition at line 218 of file power.c.

{
    PIRP SystemIrp = Context;
 
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(MinorFunction);
    ASSERT(SystemIrp != NULL);
 
    /* The system transition goes ahead even if the bus could not follow it */
    if (!NT_SUCCESS(IoStatus->Status))
    {
        DPRINT1("PCIX - Bus failed to enter device state %lu (0x%08lx)\n",
                PowerState.DeviceState,
                IoStatus->Status);
    }
 
    PoStartNextPowerIrp(SystemIrp);
    IoCompleteRequest(SystemIrp, IO_NO_INCREMENT);
}

PciFdoIrpQueryPower()

NTSTATUS NTAPI PciFdoIrpQueryPower	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 351 of file power.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    /* Refusing states that would break an armed wake is not implemented yet */
    DPRINT1("PCIX - Wake-aware power queries are not implemented, accepting the state\n");
    return STATUS_SUCCESS;
}

PciFdoSetPowerState()

NTSTATUS NTAPI PciFdoSetPowerState	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 318 of file power.c.

{
    POWER_STATE State = IoStackLocation->Parameters.Power.State;
 
    /* Bridge hardware is handled by the PDO below, so only the state is kept */
    if (IoStackLocation->Parameters.Power.Type == DevicePowerState)
    {
        DeviceExtension->PowerState.CurrentDeviceState = State.DeviceState;
        return STATUS_SUCCESS;
    }
 
    DeviceExtension->PowerState.CurrentSystemState = State.SystemState;
    if (DeviceExtension->DeviceState != PciStarted)
        return STATUS_SUCCESS;
 
    /* The bus owns its power policy and follows up with a device state request */
    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoMarkIrpPending(Irp);
    IoCopyCurrentIrpStackLocationToNext(Irp);
    IoSetCompletionRoutine(Irp,
                           PciFdoSystemPowerCompletion,
                           DeviceExtension,
                           TRUE,
                           TRUE,
                           TRUE);
    PoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
    return STATUS_PENDING;
}

PciFdoSystemPowerCompletion()

static NTSTATUS NTAPI PciFdoSystemPowerCompletion ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ PIRP  Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID  Context  )

static

Asks for the device state that matches a system set power request once the drivers below the bus have handled it.

Parameters

[in]

Context

The FDO extension of the bus.

Returns

STATUS_MORE_PROCESSING_REQUIRED while the device state request is out.

Definition at line 259 of file power.c.

{
    PPCI_FDO_EXTENSION DeviceExtension = Context;
    PIO_STACK_LOCATION IoStackLocation;
    POWER_STATE Target;
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(DeviceObject);
    ASSERT(DeviceExtension != NULL);
 
    IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
    if (IoStackLocation->Parameters.Power.State.SystemState == PowerSystemWorking)
    {
        Target.DeviceState = PowerDeviceD0;
    }
    else
    {
        Target.DeviceState = PowerDeviceD3;
    }
 
    if ((NT_SUCCESS(Irp->IoStatus.Status)) &&
        (DeviceExtension->PowerState.CurrentDeviceState != Target.DeviceState))
    {
        Status = PoRequestPowerIrp(DeviceExtension->FunctionalDeviceObject,
                                   IRP_MN_SET_POWER,
                                   Target,
                                   PciFdoDevicePowerCompletion,
                                   Irp,
                                   NULL);
        if (NT_SUCCESS(Status))
            return STATUS_MORE_PROCESSING_REQUIRED;
 
        DPRINT1("PCIX - Could not request device state %lu (0x%08lx)\n",
                Target.DeviceState,
                Status);
    }
 
    PoStartNextPowerIrp(Irp);
    return STATUS_CONTINUE_COMPLETION;
}

PciFdoWaitWake()

NTSTATUS NTAPI PciFdoWaitWake	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 305 of file power.c.

{
    UNREFERENCED_PARAMETER(IoStackLocation);
 
    /* Arming the bus for its children's wake requests is not implemented yet */
    DPRINT1("PCIX - Bus wake arming is not implemented, passing wait-wake down\n");
    return PciPassIrpFromFdoToPdo(DeviceExtension, Irp);
}

PciSetPowerManagedDevicePowerState()

NTSTATUS NTAPI PciSetPowerManagedDevicePowerState	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		IN DEVICE_POWER_STATE	DeviceState,
		IN BOOLEAN	IrpSet
	)

Definition at line 123 of file power.c.

{
    NTSTATUS Status;
    PCI_PM_CAPABILITY PmCaps;
    ULONG CapsOffset;
 
    /* Assume success */
    Status = STATUS_SUCCESS;
 
    /* Check if this device can support low power states */
    if (!(PciCanDisableDecodes(DeviceExtension, NULL, 0, TRUE)) &&
         (DeviceState != PowerDeviceD0))
    {
        /* Simply return success, ignoring this request */
        DPRINT1("PCIX - Cannot disable decodes on this device, ignoring PM request...\n");
        return Status;
    }
 
    /* Does the device support power management at all? */
    if (!(DeviceExtension->HackFlags & PCI_HACK_NO_PM_CAPS))
    {
        /* Get the PM capabilities register */
        CapsOffset = PciReadDeviceCapability(DeviceExtension,
                                             DeviceExtension->CapabilitiesPtr,
                                             PCI_CAPABILITY_ID_POWER_MANAGEMENT,
                                             &PmCaps.Header,
                                             sizeof(PCI_PM_CAPABILITY));
        ASSERT(CapsOffset);
        ASSERT(DeviceState != PowerDeviceUnspecified);
 
        /* Check if the device is being powered up */
        if (DeviceState == PowerDeviceD0)
        {
            /* Set full power state */
            PmCaps.PMCSR.ControlStatus.PowerState = 0;
 
            /* Check if the device supports Cold-D3 poweroff */
            if (PmCaps.PMC.Capabilities.Support.PMED3Cold)
            {
                /* If there was a pending PME, clear it */
                PmCaps.PMCSR.ControlStatus.PMEStatus = 1;
            }
        }
        else
        {
            /* Otherwise, just set the new power state, converting from NT */
            PmCaps.PMCSR.ControlStatus.PowerState = DeviceState - 1;
        }
 
        /* Write the new power state in the PMCSR */
        PciWriteDeviceConfig(DeviceExtension,
                             &PmCaps.PMCSR,
                             CapsOffset + FIELD_OFFSET(PCI_PM_CAPABILITY, PMCSR),
                             sizeof(PCI_PMCSR));
 
        /* Now wait for the change to "stick" based on the spec-mandated time */
        Status = PciStallForPowerChange(DeviceExtension, DeviceState, CapsOffset);
        if (!NT_SUCCESS(Status)) return Status;
    }
    else
    {
        /* Nothing to do! */
        DPRINT1("PCIX - No PM on this device, ignoring request\n");
    }
 
    /* Check if new resources have to be assigned */
    if (IrpSet)
    {
        /* Check if the new device state is lower (higher power) than now */
        if (DeviceState < DeviceExtension->PowerState.CurrentDeviceState)
        {
            /* Leaving D3 may reset the function, so write its configuration again */
            Status = PciSetResources(DeviceExtension, FALSE, FALSE);
        }
    }
 
    /* Return the power state change status */
    return Status;
}

Referenced by PciPdoEnterDevicePowerState(), PciPdoIrpStartDevice(), PciPdoTurnOff(), and PciScanBus().

PciStallForPowerChange()

NTSTATUS NTAPI PciStallForPowerChange	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN DEVICE_POWER_STATE	PowerState,
		IN ULONG_PTR	CapOffset
	)

Definition at line 45 of file power.c.

{
    ULONG PciState, TimeoutEntry, PmcsrOffset, TryCount;
    PPCI_VERIFIER_DATA VerifierData;
    LARGE_INTEGER Interval;
    PCI_PMCSR Pmcsr;
    KIRQL Irql;
 
    /* Make sure the power state is valid, and the device can support it */
    ASSERT((PdoExtension->PowerState.CurrentDeviceState >= PowerDeviceD0) &&
           (PdoExtension->PowerState.CurrentDeviceState <= PowerDeviceD3));
    ASSERT((PowerState >= PowerDeviceD0) && (PowerState <= PowerDeviceD3));
    ASSERT(!(PdoExtension->HackFlags & PCI_HACK_NO_PM_CAPS));
 
    /* Save the current IRQL */
    Irql = KeGetCurrentIrql();
 
    /* Pick the expected timeout for this transition */
    TimeoutEntry = PciPowerDelayTable[(PowerState - PowerDeviceD0) * PowerDeviceD3 +
                                      (PdoExtension->PowerState.CurrentDeviceState -
                                       PowerDeviceD0)];
 
    /* PCI power states are one less than NT power states */
    PciState = PowerState - 1;
 
    /* The state status is stored in the PMCSR offset */
    PmcsrOffset = CapOffset + FIELD_OFFSET(PCI_PM_CAPABILITY, PMCSR);
 
    /* Try changing the power state up to 100 times */
    TryCount = 100;
    while (--TryCount)
    {
        /* Check if this state transition will take time */
        if (TimeoutEntry > 0)
        {
            /* Check if this is happening at high IRQL */
            if (Irql >= DISPATCH_LEVEL)
            {
                /* Can't wait at high IRQL, stall the processor */
                KeStallExecutionProcessor(TimeoutEntry);
            }
            else
            {
                /* Do a wait for the timeout specified instead */
                Interval.QuadPart = -10 * TimeoutEntry;
                Interval.QuadPart -= KeQueryTimeIncrement() - 1;
                KeDelayExecutionThread(KernelMode, FALSE, &Interval);
            }
        }
 
        /* Read the PMCSR and see if the state has changed */
        PciReadDeviceConfig(PdoExtension, &Pmcsr, PmcsrOffset, sizeof(PCI_PMCSR));
        if (Pmcsr.PowerState == PciState) return STATUS_SUCCESS;
 
        /* Try again, forcing a timeout of 1ms */
        TimeoutEntry = 1000;
    }
 
    /* Call verifier with this error */
    VerifierData = PciVerifierRetrieveFailureData(2);
    ASSERT(VerifierData);
    VfFailDeviceNode(PdoExtension->PhysicalDeviceObject,
                     PCI_VERIFIER_DETECTED_VIOLATION,
                     2, // The PMCSR register was not updated within the spec-mandated time.
                     VerifierData->FailureClass,
                     &VerifierData->AssertionControl,
                     VerifierData->DebuggerMessageText,
                     "%DevObj%Ulong",
                     PdoExtension->PhysicalDeviceObject,
                     PciState);
 
    return STATUS_DEVICE_PROTOCOL_ERROR;
}

Referenced by PciSetPowerManagedDevicePowerState().

Variable Documentation

PciFdoDevicePowerCompletion

REQUEST_POWER_COMPLETE PciFdoDevicePowerCompletion

static

Definition at line 205 of file power.c.

Referenced by PciFdoSystemPowerCompletion().

PciFdoSystemPowerCompletion

IO_COMPLETION_ROUTINE PciFdoSystemPowerCompletion

static

Definition at line 243 of file power.c.

Referenced by PciFdoSetPowerState().

PciPowerDelayTable

ULONG PciPowerDelayTable[PowerDeviceD3 *PowerDeviceD3]

Initial value:

=
{
    0,      
    0,      
    200,    
    10000,  
 
    0,      
    0,      
    200,    
    10000,  
 
    200,    
    200,    
    0,      
    10000,  
 
    10000,  
    10000,  
    10000,  
    0       
}

Definition at line 18 of file power.c.

Referenced by PciStallForPowerChange().