power.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for power.c:

Go to the source code of this file.

Classes
struct	_POWER_STATE_TRAVERSE_CONTEXT

Macros
#define	NDEBUG

Typedefs
typedef struct _POWER_STATE_TRAVERSE_CONTEXT	POWER_STATE_TRAVERSE_CONTEXT
typedef struct _POWER_STATE_TRAVERSE_CONTEXT *	PPOWER_STATE_TRAVERSE_CONTEXT

Functions
static _Use_decl_annotations_ VOID NTAPI	PopPassivePowerCall (PVOID Parameter)
	_IRQL_requires_max_ (DISPATCH_LEVEL)
static NTSTATUS NTAPI	PopRequestPowerIrpCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)
VOID NTAPI	PopCleanupPowerState (IN PPOWER_STATE PowerState)
NTSTATUS	PopSendQuerySystemPowerState (PDEVICE_OBJECT DeviceObject, SYSTEM_POWER_STATE SystemState, POWER_ACTION PowerAction)
NTSTATUS	PopSendSetSystemPowerState (PDEVICE_OBJECT DeviceObject, SYSTEM_POWER_STATE SystemState, POWER_ACTION PowerAction)
NTSTATUS	PopQuerySystemPowerStateTraverse (PDEVICE_NODE DeviceNode, PVOID Context)
NTSTATUS	PopSetSystemPowerStateTraverse (PDEVICE_NODE DeviceNode, PVOID Context)
NTSTATUS NTAPI	PopSetSystemPowerState (SYSTEM_POWER_STATE PowerState, POWER_ACTION PowerAction)
BOOLEAN NTAPI	PoInitSystem (IN ULONG BootPhase)
VOID NTAPI	PopPerfIdle (PPROCESSOR_POWER_STATE PowerState)
VOID NTAPI	PopPerfIdleDpc (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
VOID FASTCALL	PopIdle0 (IN PPROCESSOR_POWER_STATE PowerState)
VOID NTAPI	PoInitializePrcb (IN PKPRCB Prcb)
NTSTATUS NTAPI	PoCancelDeviceNotify (IN PVOID NotifyBlock)
NTSTATUS NTAPI	PoRegisterDeviceNotify (OUT PVOID Unknown0, IN ULONG Unknown1, IN ULONG Unknown2, IN ULONG Unknown3, IN PVOID Unknown4, IN PVOID Unknown5)
VOID NTAPI	PoShutdownBugCheck (IN BOOLEAN LogError, IN ULONG BugCheckCode, IN ULONG_PTR BugCheckParameter1, IN ULONG_PTR BugCheckParameter2, IN ULONG_PTR BugCheckParameter3, IN ULONG_PTR BugCheckParameter4)
VOID NTAPI	PoSetHiberRange (IN PVOID HiberContext, IN ULONG Flags, IN OUT PVOID StartPage, IN ULONG Length, IN ULONG PageTag)
PULONG NTAPI	PoRegisterDeviceForIdleDetection (IN PDEVICE_OBJECT DeviceObject, IN ULONG ConservationIdleTime, IN ULONG PerformanceIdleTime, IN DEVICE_POWER_STATE State)
PVOID NTAPI	PoRegisterSystemState (IN PVOID StateHandle, IN EXECUTION_STATE Flags)
NTSTATUS NTAPI	PoRequestPowerIrp (_In_ PDEVICE_OBJECT DeviceObject, _In_ UCHAR MinorFunction, _In_ POWER_STATE PowerState, _In_opt_ PREQUEST_POWER_COMPLETE CompletionFunction, _In_opt_ __drv_aliasesMem PVOID Context, _Outptr_opt_ PIRP *pIrp)
POWER_STATE NTAPI	PoSetPowerState (IN PDEVICE_OBJECT DeviceObject, IN POWER_STATE_TYPE Type, IN POWER_STATE State)
VOID NTAPI	PoSetSystemState (IN EXECUTION_STATE Flags)
VOID NTAPI	PoStartNextPowerIrp (IN PIRP Irp)
VOID NTAPI	PoUnregisterSystemState (IN PVOID StateHandle)
NTSTATUS NTAPI	NtInitiatePowerAction (IN POWER_ACTION SystemAction, IN SYSTEM_POWER_STATE MinSystemState, IN ULONG Flags, IN BOOLEAN Asynchronous)
static NTSTATUS	PopQueryBatteryState (_Out_ PSYSTEM_BATTERY_STATE BatteryState)
NTSTATUS NTAPI	NtPowerInformation (IN POWER_INFORMATION_LEVEL PowerInformationLevel, IN PVOID InputBuffer OPTIONAL, IN ULONG InputBufferLength, OUT PVOID OutputBuffer OPTIONAL, IN ULONG OutputBufferLength)
NTSTATUS NTAPI	NtGetDevicePowerState (IN HANDLE Device, IN PDEVICE_POWER_STATE PowerState)
BOOLEAN NTAPI	NtIsSystemResumeAutomatic (VOID)
NTSTATUS NTAPI	NtRequestWakeupLatency (IN LATENCY_TIME Latency)
NTSTATUS NTAPI	NtSetThreadExecutionState (IN EXECUTION_STATE esFlags, OUT EXECUTION_STATE *PreviousFlags)
NTSTATUS NTAPI	NtSetSystemPowerState (IN POWER_ACTION SystemAction, IN SYSTEM_POWER_STATE MinSystemState, IN ULONG Flags)

Variables
PDEVICE_NODE	PopSystemPowerDeviceNode = NULL
BOOLEAN	PopAcpiPresent = FALSE
POP_POWER_ACTION	PopAction
WORK_QUEUE_ITEM	PopShutdownWorkItem
SYSTEM_POWER_CAPABILITIES	PopCapabilities
static WORKER_THREAD_ROUTINE	PopPassivePowerCall
static IO_COMPLETION_ROUTINE	PopRequestPowerIrpCompletion

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file power.c.

Typedef Documentation

POWER_STATE_TRAVERSE_CONTEXT

typedef struct _POWER_STATE_TRAVERSE_CONTEXT POWER_STATE_TRAVERSE_CONTEXT

PPOWER_STATE_TRAVERSE_CONTEXT

typedef struct _POWER_STATE_TRAVERSE_CONTEXT * PPOWER_STATE_TRAVERSE_CONTEXT

Function Documentation

_IRQL_requires_max_()

_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 52 of file power.c.

{
    NTSTATUS Status;
    BOOLEAN CallAtPassiveLevel;
    PDEVICE_OBJECT DeviceObject;
    PWORK_QUEUE_ITEM WorkQueueItem;
 
    ASSERT(NextStack->MajorFunction == IRP_MJ_POWER);
 
    DeviceObject = NextStack->DeviceObject;
 
    /* Determine whether the IRP must be handled at PASSIVE_LEVEL.
     * Only SET_POWER to working state can happen at raised IRQL. */
    CallAtPassiveLevel = TRUE;
    if ((NextStack->MinorFunction == IRP_MN_SET_POWER) &&
        !(DeviceObject->Flags & DO_POWER_PAGABLE))
    {
        if (NextStack->Parameters.Power.Type == DevicePowerState &&
            NextStack->Parameters.Power.State.DeviceState == PowerDeviceD0)
        {
            CallAtPassiveLevel = FALSE;
        }
        if (NextStack->Parameters.Power.Type == SystemPowerState &&
            NextStack->Parameters.Power.State.SystemState == PowerSystemWorking)
        {
            CallAtPassiveLevel = FALSE;
        }
    }
 
    if (CallAtPassiveLevel)
    {
        /* We need to fit a work item into the DriverContext below */
        C_ASSERT(sizeof(Irp->Tail.Overlay.DriverContext) >= sizeof(WORK_QUEUE_ITEM));
 
        if (KeGetCurrentIrql() == PASSIVE_LEVEL)
        {
            /* Already at passive, call next driver directly */
            return IoCallDriver(DeviceObject, Irp);
        }
 
        /* Need to schedule a work item and return pending */
        NextStack->Control |= SL_PENDING_RETURNED;
 
        WorkQueueItem = (PWORK_QUEUE_ITEM)&Irp->Tail.Overlay.DriverContext;
        ExInitializeWorkItem(WorkQueueItem,
                             PopPassivePowerCall,
                             Irp);
        ExQueueWorkItem(WorkQueueItem, DelayedWorkQueue);
 
        return STATUS_PENDING;
    }
 
    /* Direct call. Raise IRQL in debug to catch invalid paged memory access. */
#if DBG
    {
    KIRQL OldIrql;
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
#endif
 
    Status = IoCallDriver(DeviceObject, Irp);
 
#if DBG
    KeLowerIrql(OldIrql);
    }
#endif
 
    return Status;
}

NtGetDevicePowerState()

NTSTATUS NTAPI NtGetDevicePowerState	(	IN HANDLE	Device,
		IN PDEVICE_POWER_STATE	PowerState
	)

Definition at line 1045 of file power.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by GetDevicePowerState().

NtInitiatePowerAction()

NTSTATUS NTAPI NtInitiatePowerAction	(	IN POWER_ACTION	SystemAction,
		IN SYSTEM_POWER_STATE	MinSystemState,
		IN ULONG	Flags,
		IN BOOLEAN	Asynchronous
	)

Definition at line 778 of file power.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by SetSystemPowerState(), ShutDown_Hibernate(), and ShutDown_StandBy().

NtIsSystemResumeAutomatic()

BOOLEAN NTAPI NtIsSystemResumeAutomatic

(

VOID

)

Definition at line 1054 of file power.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

Referenced by IsSystemResumeAutomatic().

NtPowerInformation()

NTSTATUS NTAPI NtPowerInformation	(	IN POWER_INFORMATION_LEVEL	PowerInformationLevel,
		IN PVOID InputBuffer	OPTIONAL,
		IN ULONG	InputBufferLength,
		OUT PVOID OutputBuffer	OPTIONAL,
		IN ULONG	OutputBufferLength
	)

Definition at line 901 of file power.c.

{
    NTSTATUS Status;
    KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
 
    PAGED_CODE();
 
    DPRINT("NtPowerInformation(PowerInformationLevel 0x%x, InputBuffer 0x%p, "
           "InputBufferLength 0x%x, OutputBuffer 0x%p, OutputBufferLength 0x%x)\n",
           PowerInformationLevel,
           InputBuffer, InputBufferLength,
           OutputBuffer, OutputBufferLength);
 
    if (PreviousMode != KernelMode)
    {
        _SEH2_TRY
        {
            ProbeForRead(InputBuffer, InputBufferLength, 1);
            ProbeForWrite(OutputBuffer, OutputBufferLength, sizeof(ULONG));
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    switch (PowerInformationLevel)
    {
        case SystemBatteryState:
        {
            SYSTEM_BATTERY_STATE BatteryState;
 
            if (InputBuffer != NULL)
                return STATUS_INVALID_PARAMETER;
            if (OutputBufferLength < sizeof(SYSTEM_BATTERY_STATE))
                return STATUS_BUFFER_TOO_SMALL;
 
            if (PopCapabilities.SystemBatteriesPresent)
            {
                /* Open the battery driver and query the battery state */
                Status = PopQueryBatteryState(&BatteryState);
                if (!NT_SUCCESS(Status))
                {
                    DPRINT1("Failed to query battery state: Status: 0x%08X\n", Status);
                    return Status;
                }
            }
            else
            {
                /* No batteries present, set defaults */
                RtlZeroMemory(&BatteryState, sizeof(BatteryState));
                BatteryState.AcOnLine = TRUE;
            }
 
            _SEH2_TRY
            {
                /* Copy the battery state to the output buffer */
                RtlCopyMemory(OutputBuffer, &BatteryState, sizeof(BatteryState));
                Status = STATUS_SUCCESS;
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                Status = _SEH2_GetExceptionCode();
            }
            _SEH2_END;
 
            break;
        }
 
        case SystemPowerCapabilities:
        {
            PSYSTEM_POWER_CAPABILITIES PowerCapabilities = (PSYSTEM_POWER_CAPABILITIES)OutputBuffer;
 
            if (InputBuffer != NULL)
                return STATUS_INVALID_PARAMETER;
            if (OutputBufferLength < sizeof(SYSTEM_POWER_CAPABILITIES))
                return STATUS_BUFFER_TOO_SMALL;
 
            _SEH2_TRY
            {
                RtlCopyMemory(PowerCapabilities,
                              &PopCapabilities,
                              sizeof(SYSTEM_POWER_CAPABILITIES));
 
                Status = STATUS_SUCCESS;
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                Status = _SEH2_GetExceptionCode();
            }
            _SEH2_END;
 
            break;
        }
 
        case ProcessorInformation:
        {
            PPROCESSOR_POWER_INFORMATION PowerInformation = (PPROCESSOR_POWER_INFORMATION)OutputBuffer;
 
            if (InputBuffer != NULL)
                return STATUS_INVALID_PARAMETER;
            if (OutputBufferLength < sizeof(PROCESSOR_POWER_INFORMATION))
                return STATUS_BUFFER_TOO_SMALL;
 
            /* FIXME: return structures for all processors */
 
            _SEH2_TRY
            {
                /* FIXME: some values are hardcoded */
                PowerInformation->Number = 0;
                PowerInformation->MaxMhz = 1000;
                PowerInformation->CurrentMhz = KeGetCurrentPrcb()->MHz;
                PowerInformation->MhzLimit = 1000;
                PowerInformation->MaxIdleState = 0;
                PowerInformation->CurrentIdleState = 0;
 
                Status = STATUS_SUCCESS;
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                Status = _SEH2_GetExceptionCode();
            }
            _SEH2_END;
 
            break;
        }
 
        default:
            Status = STATUS_NOT_IMPLEMENTED;
            DPRINT1("PowerInformationLevel 0x%x is UNIMPLEMENTED! Have a nice day.\n",
                    PowerInformationLevel);
            break;
    }
 
    return Status;
}

Referenced by CallNtPowerInformation(), get_processor_currentclockspeed(), get_processor_maxclockspeed(), GetAllowedShutdownOptions(), GetPwrCapabilities(), GetSystemPowerStatus(), InitFunctionPtrs(), IsPwrHibernateAllowed(), IsPwrShutdownAllowed(), IsPwrSuspendAllowed(), and ValidatePowerPolicies().

NtRequestWakeupLatency()

NTSTATUS NTAPI NtRequestWakeupLatency

(

IN LATENCY_TIME

Latency

)

Definition at line 1062 of file power.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by RequestWakeupLatency().

NtSetSystemPowerState()

NTSTATUS NTAPI NtSetSystemPowerState	(	IN POWER_ACTION	SystemAction,
		IN SYSTEM_POWER_STATE	MinSystemState,
		IN ULONG	Flags
	)

Definition at line 1127 of file power.c.

{
    KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
    POP_POWER_ACTION Action = {0};
    NTSTATUS Status;
    ULONG Dummy;
 
    /* Check for invalid parameter combinations */
    if ((MinSystemState >= PowerSystemMaximum) ||
        (MinSystemState <= PowerSystemUnspecified) ||
        (SystemAction > PowerActionWarmEject) ||
        (SystemAction < PowerActionReserved) ||
        (Flags & ~(POWER_ACTION_QUERY_ALLOWED  |
                   POWER_ACTION_UI_ALLOWED     |
                   POWER_ACTION_OVERRIDE_APPS  |
                   POWER_ACTION_LIGHTEST_FIRST |
                   POWER_ACTION_LOCK_CONSOLE   |
                   POWER_ACTION_DISABLE_WAKES  |
                   POWER_ACTION_CRITICAL)))
    {
        DPRINT1("NtSetSystemPowerState: Bad parameters!\n");
        DPRINT1("                       SystemAction: 0x%x\n", SystemAction);
        DPRINT1("                       MinSystemState: 0x%x\n", MinSystemState);
        DPRINT1("                       Flags: 0x%x\n", Flags);
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check for user caller */
    if (PreviousMode != KernelMode)
    {
        /* Check for shutdown permission */
        if (!SeSinglePrivilegeCheck(SeShutdownPrivilege, PreviousMode))
        {
            /* Not granted */
            DPRINT1("ERROR: Privilege not held for shutdown\n");
            return STATUS_PRIVILEGE_NOT_HELD;
        }
 
        /* Do it as a kernel-mode caller for consistency with system state */
        return ZwSetSystemPowerState(SystemAction, MinSystemState, Flags);
    }
 
    /* Read policy settings (partial shutdown vs. full shutdown) */
    if (SystemAction == PowerActionShutdown) PopReadShutdownPolicy();
 
    /* Disable lazy flushing of registry */
    DPRINT("Stopping lazy flush\n");
    CmSetLazyFlushState(FALSE);
 
    /* Setup the power action */
    Action.Action = SystemAction;
    Action.Flags = Flags;
 
    /* Notify callbacks */
    DPRINT("Notifying callbacks\n");
    ExNotifyCallback(PowerStateCallback, (PVOID)3, NULL);
 
    /* Swap in any worker thread stacks */
    DPRINT("Swapping worker threads\n");
    ExSwapinWorkerThreads(FALSE);
 
    /* Make our action global */
    PopAction = Action;
 
    /* Start power loop */
    Status = STATUS_CANCELLED;
    while (TRUE)
    {
        /* Break out if there's nothing to do */
        if (Action.Action == PowerActionNone) break;
 
        /* Check for first-pass or restart */
        if (Status == STATUS_CANCELLED)
        {
            /* Check for shutdown action */
            if ((PopAction.Action == PowerActionShutdown) ||
                (PopAction.Action == PowerActionShutdownReset) ||
                (PopAction.Action == PowerActionShutdownOff))
            {
                /* Set the action */
                PopAction.Shutdown = TRUE;
            }
 
            /* Now we are good to go */
            Status = STATUS_SUCCESS;
        }
 
        /* Check if we're still in an invalid status */
        if (!NT_SUCCESS(Status)) break;
 
        /* Flush all volumes and the registry */
        DPRINT("Flushing volumes\n");
        PopFlushVolumes(PopAction.Shutdown);
 
#ifndef NEWCC
        /* Flush dirty cache pages */
        /* XXX: Is that still mandatory? As now we'll wait on lazy writer to complete? */
        CcRosFlushDirtyPages(MAXULONG, &Dummy, TRUE, FALSE);
        DPRINT("Cache flushed %lu pages\n", Dummy);
#else
        Dummy = 0;
#endif
 
        /* Set IRP for drivers */
        PopAction.IrpMinor = IRP_MN_SET_POWER;
        if (PopAction.Shutdown)
        {
            DPRINT("Queueing shutdown thread\n");
            /* Check if we are running in the system context */
            if (PsGetCurrentProcess() != PsInitialSystemProcess)
            {
                /* We're not, so use a worker thread for shutdown */
                ExInitializeWorkItem(&PopShutdownWorkItem,
                                     &PopGracefulShutdown,
                                     NULL);
 
                ExQueueWorkItem(&PopShutdownWorkItem, CriticalWorkQueue);
 
                /* Spend us -- when we wake up, the system is good to go down */
                KeSuspendThread(KeGetCurrentThread());
                Status = STATUS_SYSTEM_SHUTDOWN;
                goto Exit;
 
            }
            else
            {
                /* Do the shutdown inline */
                PopGracefulShutdown(NULL);
            }
        }
 
        /* You should not have made it this far */
        // ASSERTMSG("System is still up and running?!\n", FALSE);
        DPRINT1("System is still up and running, you may not have chosen a yet supported power option: %u\n", PopAction.Action);
        break;
    }
 
Exit:
    /* We're done, return */
    return Status;
}

Referenced by NtShutdownSystem(), ShutDown_Hibernate(), and ShutDown_StandBy().

NtSetThreadExecutionState()

NTSTATUS NTAPI NtSetThreadExecutionState	(	IN EXECUTION_STATE	esFlags,
		OUT EXECUTION_STATE *	PreviousFlags
	)

Definition at line 1070 of file power.c.

{
    PKTHREAD Thread = KeGetCurrentThread();
    KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
    EXECUTION_STATE PreviousState;
    PAGED_CODE();
 
    /* Validate flags */
    if (esFlags & ~(ES_CONTINUOUS | ES_USER_PRESENT))
    {
        /* Fail the request */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check for user parameters */
    if (PreviousMode != KernelMode)
    {
        /* Protect the probes */
        _SEH2_TRY
        {
            /* Check if the pointer is valid */
            ProbeForWriteUlong(PreviousFlags);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* It isn't -- fail */
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    /* Save the previous state, always masking in the continous flag */
    PreviousState = Thread->PowerState | ES_CONTINUOUS;
 
    /* Check if we need to update the power state */
    if (esFlags & ES_CONTINUOUS) Thread->PowerState = (UCHAR)esFlags;
 
    /* Protect the write back to user mode */
    _SEH2_TRY
    {
        /* Return the previous flags */
        *PreviousFlags = PreviousState;
    }
    _SEH2_EXCEPT(ExSystemExceptionFilter())
    {
        /* Something's wrong, fail */
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    /* All is good */
    return STATUS_SUCCESS;
}

Referenced by SetThreadExecutionState().

PoCancelDeviceNotify()

NTSTATUS NTAPI PoCancelDeviceNotify

(

IN PVOID

NotifyBlock

)

Definition at line 532 of file power.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

PoInitializePrcb()

VOID NTAPI PoInitializePrcb

(

IN PKPRCB

Prcb

)

Definition at line 510 of file power.c.

{
    /* Initialize the Power State */
    RtlZeroMemory(&Prcb->PowerState, sizeof(Prcb->PowerState));
    Prcb->PowerState.Idle0KernelTimeLimit = 0xFFFFFFFF;
    Prcb->PowerState.CurrentThrottle = 100;
    Prcb->PowerState.CurrentThrottleIndex = 0;
    Prcb->PowerState.IdleFunction = PopIdle0;
 
    /* Initialize the Perf DPC and Timer */
    KeInitializeDpc(&Prcb->PowerState.PerfDpc, PopPerfIdleDpc, Prcb);
    KeSetTargetProcessorDpc(&Prcb->PowerState.PerfDpc, Prcb->Number);
    KeInitializeTimerEx(&Prcb->PowerState.PerfTimer, SynchronizationTimer);
}

Referenced by KiInitializeKernel(), and KiSystemStartupBootStack().

PoInitSystem()

BOOLEAN NTAPI PoInitSystem

(

IN ULONG

BootPhase

)

Definition at line 397 of file power.c.

{
    PVOID NotificationEntry;
    PCHAR CommandLine;
    BOOLEAN ForceAcpiDisable = FALSE;
 
    /* Check if this is phase 1 init */
    if (BootPhase == 1)
    {
        NTSTATUS Status;
        /* Register power button notification */
        Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                                PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                                (PVOID)&GUID_DEVICE_SYS_BUTTON,
                                                IopRootDeviceNode->PhysicalDeviceObject->DriverObject,
                                                PopAddRemoveSysCapsCallback,
                                                (PVOID)(ULONG_PTR)PolicyDeviceSystemButton,
                                                &NotificationEntry);
        if (!NT_SUCCESS(Status))
            return FALSE;
 
        /* Register lid notification */
        Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                                PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                                (PVOID)&GUID_DEVICE_LID,
                                                IopRootDeviceNode->PhysicalDeviceObject->DriverObject,
                                                PopAddRemoveSysCapsCallback,
                                                (PVOID)(ULONG_PTR)PolicyDeviceSystemButton,
                                                &NotificationEntry);
        if (!NT_SUCCESS(Status))
            return FALSE;
 
        /* Register battery notification */
        Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                                PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                                (PVOID)&GUID_DEVICE_BATTERY,
                                                IopRootDeviceNode->PhysicalDeviceObject->DriverObject,
                                                PopAddRemoveSysCapsCallback,
                                                (PVOID)(ULONG_PTR)PolicyDeviceBattery,
                                                &NotificationEntry);
 
        return NT_SUCCESS(Status);
    }
 
    /* Initialize the power capabilities */
    RtlZeroMemory(&PopCapabilities, sizeof(SYSTEM_POWER_CAPABILITIES));
 
    /* Get the Command Line */
    CommandLine = KeLoaderBlock->LoadOptions;
 
    /* Upcase it */
    _strupr(CommandLine);
 
    /* Check for ACPI disable */
    if (strstr(CommandLine, "NOACPI")) ForceAcpiDisable = TRUE;
 
    if (ForceAcpiDisable)
    {
        /* Set the ACPI State to False if it's been forced that way */
        PopAcpiPresent = FALSE;
    }
    else
    {
        /* Otherwise check if the LoaderBlock has a ACPI Table  */
        PopAcpiPresent = KeLoaderBlock->Extension->AcpiTable != NULL ? TRUE : FALSE;
    }
 
    /* Enable shutdown by power button */
    if (PopAcpiPresent)
        PopCapabilities.SystemS5 = TRUE;
 
    /* Initialize volume support */
    InitializeListHead(&PopVolumeDevices);
    KeInitializeGuardedMutex(&PopVolumeLock);
 
    /* Initialize support for dope */
    KeInitializeSpinLock(&PopDopeGlobalLock);
 
    /* Initialize support for shutdown waits and work-items */
    PopInitShutdownList();
 
    return TRUE;
}

Referenced by Phase1InitializationDiscard().

PopCleanupPowerState()

VOID NTAPI PopCleanupPowerState

(

IN PPOWER_STATE

PowerState

)

Definition at line 164 of file power.c.

{
    //UNIMPLEMENTED;
}

Referenced by PspExitProcess(), and PspExitThread().

PopIdle0()

VOID FASTCALL PopIdle0

(

IN PPROCESSOR_POWER_STATE

PowerState

)

Definition at line 501 of file power.c.

{
    /* FIXME: Extremly naive implementation */
    HalProcessorIdle();
}

Referenced by PoInitializePrcb().

PopPassivePowerCall()

static _Use_decl_annotations_ VOID NTAPI PopPassivePowerCall ( PVOID  Parameter )

static

Definition at line 38 of file power.c.

{
    PIRP Irp = Parameter;
    PIO_STACK_LOCATION IoStack;
 
    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 
    _Analysis_assume_(Irp != NULL);
    IoStack = IoGetNextIrpStackLocation(Irp);
 
    (VOID)IoCallDriver(IoStack->DeviceObject, Irp);
}

PopPerfIdle()

VOID NTAPI PopPerfIdle

(

PPROCESSOR_POWER_STATE

PowerState

)

Definition at line 483 of file power.c.

{
    DPRINT1("PerfIdle function: %p\n", PowerState);
}

Referenced by PopPerfIdleDpc().

PopPerfIdleDpc()

VOID NTAPI PopPerfIdleDpc	(	IN PKDPC	Dpc,
		IN PVOID	DeferredContext,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2
	)

Definition at line 490 of file power.c.

{
    /* Call the Perf Idle function */
    PopPerfIdle(&((PKPRCB)DeferredContext)->PowerState);
}

Referenced by PoInitializePrcb().

PopQueryBatteryState()

static NTSTATUS PopQueryBatteryState ( _Out_ PSYSTEM_BATTERY_STATE  BatteryState )

static

Definition at line 789 of file power.c.

{
    static const UNICODE_STRING CompBattDeviceName =
        RTL_CONSTANT_STRING(L"\\Device\\CompositeBattery");
    OBJECT_ATTRIBUTES ObjectAttributes = RTL_CONSTANT_OBJECT_ATTRIBUTES(
        &CompBattDeviceName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE);
    HANDLE CompBattHandle;
    IO_STATUS_BLOCK IoStatusBlock;
    BATTERY_QUERY_INFORMATION BatteryQueryInfo = {0};
    BATTERY_INFORMATION BatteryInfo = { 0 };
    BATTERY_STATUS BatteryStatus;
    NTSTATUS Status;
 
    /* Open the CompositeBattery device */
    Status = ZwOpenFile(&CompBattHandle,
                        GENERIC_READ | SYNCHRONIZE,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to open CompositeBattery device: Status: 0x%08lX\n", Status);
        return Status;
    }
 
    /* Query the battery tag */
    ULONG Wait = 0;
    Status = ZwDeviceIoControlFile(CompBattHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &IoStatusBlock,
                                   IOCTL_BATTERY_QUERY_TAG,
                                   &Wait,
                                   sizeof(Wait),
                                   &BatteryQueryInfo.BatteryTag,
                                   sizeof(BatteryQueryInfo.BatteryTag));
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to query battery tag: Status: 0x%08lX\n", Status);
        goto Exit;
    }
 
    /* Query the battery information */
    BatteryQueryInfo.InformationLevel = BatteryInformation;
    Status = ZwDeviceIoControlFile(CompBattHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &IoStatusBlock,
                                   IOCTL_BATTERY_QUERY_INFORMATION,
                                   &BatteryQueryInfo,
                                   sizeof(BatteryQueryInfo),
                                   &BatteryInfo,
                                   sizeof(BatteryInfo));
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to query battery information: Status: 0x%08lX\n", Status);
    }
 
    /* Query the battery status */
    BATTERY_WAIT_STATUS BatteryWait = {0};
    BatteryWait.BatteryTag = BatteryQueryInfo.BatteryTag;
    BatteryWait.PowerState = 0xF ; // Wait for all power states
    BatteryWait.HighCapacity = MAXULONG;
    Status = ZwDeviceIoControlFile(CompBattHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &IoStatusBlock,
                                   IOCTL_BATTERY_QUERY_STATUS,
                                   &BatteryWait,
                                   sizeof(BatteryWait),
                                   &BatteryStatus,
                                   sizeof(BatteryStatus));
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to query battery status: Status: 0x%08lX\n", Status);
        goto Exit;
    }
 
    RtlZeroMemory(BatteryState, sizeof(*BatteryState));
    BatteryState->BatteryPresent = TRUE;
    BatteryState->AcOnLine = BooleanFlagOn(BatteryStatus.PowerState, BATTERY_POWER_ON_LINE);
    BatteryState->Charging = BooleanFlagOn(BatteryStatus.PowerState, BATTERY_CHARGING);
    BatteryState->Discharging = BooleanFlagOn(BatteryStatus.PowerState, BATTERY_DISCHARGING);
    BatteryState->MaxCapacity = BatteryInfo.FullChargedCapacity;
    BatteryState->RemainingCapacity = BatteryStatus.Capacity;
    BatteryState->Rate = BatteryStatus.Rate;
    if (BatteryState->Discharging && BatteryStatus.Rate < 0)
    {
        BatteryState->EstimatedTime =
            3600 * BatteryInfo.FullChargedCapacity / -BatteryStatus.Rate;
    }
    else
    {
        BatteryState->EstimatedTime = 0;
    }
 
Exit:
    ZwClose(CompBattHandle);
    return Status;
}

Referenced by NtPowerInformation().

PopQuerySystemPowerStateTraverse()

NTSTATUS PopQuerySystemPowerStateTraverse	(	PDEVICE_NODE	DeviceNode,
		PVOID	Context
	)

Definition at line 254 of file power.c.

{
    PPOWER_STATE_TRAVERSE_CONTEXT PowerStateContext = Context;
    PDEVICE_OBJECT TopDeviceObject;
    NTSTATUS Status;
 
    DPRINT("PopQuerySystemPowerStateTraverse(%p, %p)\n", DeviceNode, Context);
 
    if (DeviceNode == IopRootDeviceNode)
        return STATUS_SUCCESS;
 
    if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
        return STATUS_SUCCESS;
 
    TopDeviceObject = IoGetAttachedDeviceReference(DeviceNode->PhysicalDeviceObject);
 
    Status = PopSendQuerySystemPowerState(TopDeviceObject,
                                          PowerStateContext->SystemPowerState,
                                          PowerStateContext->PowerAction);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Device '%wZ' failed IRP_MN_QUERY_POWER\n", &DeviceNode->InstancePath);
    }
    ObDereferenceObject(TopDeviceObject);
 
#if 0
    return Status;
#else
    return STATUS_SUCCESS;
#endif
}

Referenced by PopSetSystemPowerState().

PopRequestPowerIrpCompletion()

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

static

Definition at line 132 of file power.c.

{
    PIO_STACK_LOCATION Stack;
    PREQUEST_POWER_COMPLETE CompletionRoutine;
    POWER_STATE PowerState;
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
    CompletionRoutine = Context;
 
    PowerState.DeviceState = (ULONG_PTR)Stack->Parameters.Others.Argument3;
 
    if (CompletionRoutine)
    {
        CompletionRoutine(Stack->Parameters.Others.Argument1,
                          (UCHAR)(ULONG_PTR)Stack->Parameters.Others.Argument2,
                          PowerState,
                          Stack->Parameters.Others.Argument4,
                          &Irp->IoStatus);
    }
 
    IoSkipCurrentIrpStackLocation(Irp);
    IoFreeIrp(Irp);
    ObDereferenceObject(DeviceObject);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

PopSendQuerySystemPowerState()

NTSTATUS PopSendQuerySystemPowerState	(	PDEVICE_OBJECT	DeviceObject,
		SYSTEM_POWER_STATE	SystemState,
		POWER_ACTION	PowerAction
	)

Definition at line 170 of file power.c.

{
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;
    PIO_STACK_LOCATION IrpSp;
    PIRP Irp;
    NTSTATUS Status;
 
    KeInitializeEvent(&Event,
                      NotificationEvent,
                      FALSE);
 
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_POWER,
                                       DeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatusBlock);
    if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
 
    IrpSp = IoGetNextIrpStackLocation(Irp);
    IrpSp->MinorFunction = IRP_MN_QUERY_POWER;
    IrpSp->Parameters.Power.Type = SystemPowerState;
    IrpSp->Parameters.Power.State.SystemState = SystemState;
    IrpSp->Parameters.Power.ShutdownType = PowerAction;
 
    Status = PoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    return Status;
}

Referenced by PopQuerySystemPowerStateTraverse().

PopSendSetSystemPowerState()

NTSTATUS PopSendSetSystemPowerState	(	PDEVICE_OBJECT	DeviceObject,
		SYSTEM_POWER_STATE	SystemState,
		POWER_ACTION	PowerAction
	)

Definition at line 212 of file power.c.

{
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;
    PIO_STACK_LOCATION IrpSp;
    PIRP Irp;
    NTSTATUS Status;
 
    KeInitializeEvent(&Event,
                      NotificationEvent,
                      FALSE);
 
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_POWER,
                                       DeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatusBlock);
    if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
 
    IrpSp = IoGetNextIrpStackLocation(Irp);
    IrpSp->MinorFunction = IRP_MN_SET_POWER;
    IrpSp->Parameters.Power.Type = SystemPowerState;
    IrpSp->Parameters.Power.State.SystemState = SystemState;
    IrpSp->Parameters.Power.ShutdownType = PowerAction;
 
    Status = PoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    return Status;
}

Referenced by PopSetSystemPowerState(), and PopSetSystemPowerStateTraverse().

PopSetSystemPowerState()

NTSTATUS NTAPI PopSetSystemPowerState	(	SYSTEM_POWER_STATE	PowerState,
		POWER_ACTION	PowerAction
	)

Definition at line 332 of file power.c.

{
    PDEVICE_OBJECT DeviceObject;
    PDEVICE_OBJECT Fdo;
    NTSTATUS Status;
    DEVICETREE_TRAVERSE_CONTEXT Context;
    POWER_STATE_TRAVERSE_CONTEXT PowerContext;
 
    Status = IopGetSystemPowerDeviceObject(&DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("No system power driver available\n");
        Fdo = NULL;
    }
    else
    {
        Fdo = IoGetAttachedDeviceReference(DeviceObject);
        if (Fdo == DeviceObject)
        {
            DPRINT("An FDO was not attached\n");
            return STATUS_UNSUCCESSFUL;
        }
    }
 
    /* Set up context */
    PowerContext.PowerAction = PowerAction;
    PowerContext.SystemPowerState = PowerState;
    PowerContext.PowerDevice = Fdo;
 
    /* Query for system power change */
    IopInitDeviceTreeTraverseContext(&Context,
                                     IopRootDeviceNode,
                                     PopQuerySystemPowerStateTraverse,
                                     &PowerContext);
 
    Status = IopTraverseDeviceTree(&Context);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Query system power state failed; changing state anyway\n");
    }
 
    /* Set system power change */
    IopInitDeviceTreeTraverseContext(&Context,
                                     IopRootDeviceNode,
                                     PopSetSystemPowerStateTraverse,
                                     &PowerContext);
 
    IopTraverseDeviceTree(&Context);
 
    if (!PopAcpiPresent) return STATUS_NOT_IMPLEMENTED;
 
    if (Fdo != NULL)
    {
        if (PowerAction != PowerActionShutdownReset)
            PopSendSetSystemPowerState(Fdo, PowerState, PowerAction);
 
        ObDereferenceObject(Fdo);
    }
 
    return Status;
}

Referenced by PopShutdownSystem().

PopSetSystemPowerStateTraverse()

NTSTATUS PopSetSystemPowerStateTraverse	(	PDEVICE_NODE	DeviceNode,
		PVOID	Context
	)

Definition at line 288 of file power.c.

{
    PPOWER_STATE_TRAVERSE_CONTEXT PowerStateContext = Context;
    PDEVICE_OBJECT TopDeviceObject;
    NTSTATUS Status;
 
    DPRINT("PopSetSystemPowerStateTraverse(%p, %p)\n", DeviceNode, Context);
 
    if (DeviceNode == IopRootDeviceNode)
        return STATUS_SUCCESS;
 
    if (DeviceNode->PhysicalDeviceObject == PowerStateContext->PowerDevice)
        return STATUS_SUCCESS;
 
    if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
        return STATUS_SUCCESS;
 
    TopDeviceObject = IoGetAttachedDeviceReference(DeviceNode->PhysicalDeviceObject);
    if (TopDeviceObject == PowerStateContext->PowerDevice)
    {
        ObDereferenceObject(TopDeviceObject);
        return STATUS_SUCCESS;
    }
 
    Status = PopSendSetSystemPowerState(TopDeviceObject,
                                        PowerStateContext->SystemPowerState,
                                        PowerStateContext->PowerAction);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Device '%wZ' failed IRP_MN_SET_POWER\n", &DeviceNode->InstancePath);
    }
 
    ObDereferenceObject(TopDeviceObject);
 
#if 0
    return Status;
#else
    return STATUS_SUCCESS;
#endif
}

Referenced by PopSetSystemPowerState().

PoRegisterDeviceForIdleDetection()

PULONG NTAPI PoRegisterDeviceForIdleDetection	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	ConservationIdleTime,
		IN ULONG	PerformanceIdleTime,
		IN DEVICE_POWER_STATE	State
	)

Definition at line 633 of file power.c.

{
    UNIMPLEMENTED;
    return NULL;
}

PoRegisterDeviceNotify()

NTSTATUS NTAPI PoRegisterDeviceNotify	(	OUT PVOID	Unknown0,
		IN ULONG	Unknown1,
		IN ULONG	Unknown2,
		IN ULONG	Unknown3,
		IN PVOID	Unknown4,
		IN PVOID	Unknown5
	)

Definition at line 543 of file power.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

PoRegisterSystemState()

PVOID NTAPI PoRegisterSystemState	(	IN PVOID	StateHandle,
		IN EXECUTION_STATE	Flags
	)

Definition at line 647 of file power.c.

{
    UNIMPLEMENTED;
    return NULL;
}

PoRequestPowerIrp()

NTSTATUS NTAPI PoRequestPowerIrp	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ UCHAR	MinorFunction,
		_In_ POWER_STATE	PowerState,
		_In_opt_ PREQUEST_POWER_COMPLETE	CompletionFunction,
		_In_opt_ __drv_aliasesMem PVOID	Context,
		_Outptr_opt_ PIRP *	pIrp
	)

Definition at line 659 of file power.c.

{
    PDEVICE_OBJECT TopDeviceObject;
    PIO_STACK_LOCATION Stack;
    PIRP Irp;
 
    if (MinorFunction != IRP_MN_QUERY_POWER
        && MinorFunction != IRP_MN_SET_POWER
        && MinorFunction != IRP_MN_WAIT_WAKE)
        return STATUS_INVALID_PARAMETER_2;
 
    /* Always call the top of the device stack */
    TopDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
 
    Irp = IoAllocateIrp(TopDeviceObject->StackSize + 2, FALSE);
    if (!Irp)
    {
        ObDereferenceObject(TopDeviceObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
    Irp->IoStatus.Information = 0;
 
    IoSetNextIrpStackLocation(Irp);
 
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->Parameters.Others.Argument1 = DeviceObject;
    Stack->Parameters.Others.Argument2 = (PVOID)(ULONG_PTR)MinorFunction;
    Stack->Parameters.Others.Argument3 = (PVOID)(ULONG_PTR)PowerState.DeviceState;
    Stack->Parameters.Others.Argument4 = Context;
    Stack->DeviceObject = TopDeviceObject;
    IoSetNextIrpStackLocation(Irp);
 
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = IRP_MJ_POWER;
    Stack->MinorFunction = MinorFunction;
    if (MinorFunction == IRP_MN_WAIT_WAKE)
    {
        Stack->Parameters.WaitWake.PowerState = PowerState.SystemState;
    }
    else
    {
        Stack->Parameters.Power.Type = DevicePowerState;
        Stack->Parameters.Power.State = PowerState;
    }
 
    if (pIrp != NULL)
        *pIrp = Irp;
 
    IoSetCompletionRoutine(Irp, PopRequestPowerIrpCompletion, CompletionFunction, TRUE, TRUE, TRUE);
    PoCallDriver(TopDeviceObject, Irp);
 
    /* Always return STATUS_PENDING. The completion routine
     * will call CompletionFunction and complete the Irp.
     */
    return STATUS_PENDING;
}

Referenced by CmBattPnpDispatch(), CmBattWaitWakeLoop(), IdleNotificationCallback(), IdleNotificationRequestComplete(), IssueWaitWake(), PcRequestNewPowerState(), PortClsPower(), SendDeviceIrp(), TestPoRequestPowerIrp(), USBH_FdoIdleNotificationCallback(), USBH_FdoPower(), USBH_FdoSubmitWaitWakeIrp(), USBH_FdoWWIrpIoCompletion(), USBH_HubSetD0(), and WaitWakeCallback().

PoSetHiberRange()

VOID NTAPI PoSetHiberRange	(	IN PVOID	HiberContext,
		IN ULONG	Flags,
		IN OUT PVOID	StartPage,
		IN ULONG	Length,
		IN ULONG	PageTag
	)

Definition at line 584 of file power.c.

{
    UNIMPLEMENTED;
    return;
}

PoSetPowerState()

POWER_STATE NTAPI PoSetPowerState	(	IN PDEVICE_OBJECT	DeviceObject,
		IN POWER_STATE_TYPE	Type,
		IN POWER_STATE	State
	)

Definition at line 729 of file power.c.

{
    POWER_STATE ps;
 
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    ps.SystemState = PowerSystemWorking;  // Fully on
    ps.DeviceState = PowerDeviceD0;       // Fully on
 
    return ps;
}

Referenced by Bus_PDO_PnP(), Bus_PDO_Power(), Bus_StartFdo(), ClasspDeviceLockFailurePowerIrpCompletion(), ClasspPowerDownCompletion(), ClasspPowerHandler(), ClasspPowerUpCompletion(), FinishDevPoDnIrp(), FreeBT_AddDevice(), KbdHid_AddDevice(), MouHid_AddDevice(), PciPdoIrpStartDevice(), PcmciaPower(), PortClsPnp(), PortClsPower(), SetDeviceFunctional(), and MxDeviceObject::SetPowerState().

PoSetSystemState()

VOID NTAPI PoSetSystemState

(

IN EXECUTION_STATE

Flags

)

Definition at line 748 of file power.c.

{
    UNIMPLEMENTED;
}

PoShutdownBugCheck()

VOID NTAPI PoShutdownBugCheck	(	IN BOOLEAN	LogError,
		IN ULONG	BugCheckCode,
		IN ULONG_PTR	BugCheckParameter1,
		IN ULONG_PTR	BugCheckParameter2,
		IN ULONG_PTR	BugCheckParameter3,
		IN ULONG_PTR	BugCheckParameter4
	)

Definition at line 559 of file power.c.

{
    DPRINT1("PoShutdownBugCheck called\n");
 
    /* FIXME: Log error if requested */
    /* FIXME: Initiate a shutdown */
 
    /* Bugcheck the system */
    KeBugCheckEx(BugCheckCode,
                 BugCheckParameter1,
                 BugCheckParameter2,
                 BugCheckParameter3,
                 BugCheckParameter4);
}

PoStartNextPowerIrp()

VOID NTAPI PoStartNextPowerIrp

(

IN PIRP

Irp

)

Definition at line 758 of file power.c.

{
    UNIMPLEMENTED_ONCE;
}

Referenced by _Dispatch_type_(), Bus_FDO_Power(), Bus_PDO_Power(), CancelWaitWake(), ClassDispatchPower(), ClassDispatchUnimplemented(), ClassMinimalPowerHandler(), ClasspDeviceLockFailurePowerIrpCompletion(), ClassPower(), ClasspPowerDownCompletion(), ClasspPowerHandler(), ClasspPowerUpCompletion(), ClasspStartNextPowerIrpCompletion(), CmBattPowerDispatch(), CompBattPowerDispatch(), DevPoCompletionRoutine(), FdcPower(), FDO_Dispatch(), FdoPower(), FdoPowerControl(), FinishDevPoDnIrp(), FinishDevPoUpIrp(), FreeBT_DispatchPower(), GreenPower(), HalpDispatchPower(), HandleDeviceQueryPower(), HandleDeviceSetPower(), HandleSystemQueryPower(), HDA_Power(), HidClass_Power(), HidPower(), i8042Power(), InPortPower(), IntVideoPortDispatchPower(), KbdHid_Power(), KsDefaultDispatchPower(), MouHid_Power(), NdisIPower(), PartMgrPower(), PciDispatchIrp(), PciIdeXFdoDispatchPower(), PciIdeXPdoDispatchPower(), PciPassIrpFromFdoToPdo(), PDO_HandlePower(), PdoPower(), PdoPowerControl(), PnpRootPowerControl(), PortClsPower(), ProcessorPower(), PwrCompletionFunction(), RamdiskPower(), RequestedPowerIrpHandler(), ScsiPortDispatchPower(), SendDeviceIrp(), SerialPower(), SetDeviceFunctional(), SwDispatchPower(), SysPoCompletionRoutine(), USBH_CompletePowerIrp(), USBH_FdoDeferPoRequestCompletion(), USBH_FdoPower(), USBH_FdoWWIrpIoCompletion(), USBH_HubCancelWakeIrp(), USBH_PdoPower(), USBH_PowerIrpCompletion(), USBPORT_FdoPower(), USBPORT_PdoPower(), USBSTOR_DispatchPower(), and WaitWakeCompletionRoutine().

PoUnregisterSystemState()

VOID NTAPI PoUnregisterSystemState

(

IN PVOID

StateHandle

)

Definition at line 768 of file power.c.

{
    UNIMPLEMENTED;
}

Variable Documentation

PopAcpiPresent

BOOLEAN PopAcpiPresent = FALSE

Definition at line 26 of file power.c.

Referenced by PoInitSystem(), and PopSetSystemPowerState().

PopAction

POP_POWER_ACTION PopAction

Definition at line 27 of file power.c.

Referenced by NtSetSystemPowerState(), and PopGracefulShutdown().

PopCapabilities

SYSTEM_POWER_CAPABILITIES PopCapabilities

Definition at line 29 of file power.c.

Referenced by NtPowerInformation(), PoInitSystem(), and PopAddRemoveSysCapsCallback().

PopPassivePowerCall

WORKER_THREAD_ROUTINE PopPassivePowerCall

static

Definition at line 33 of file power.c.

Referenced by _IRQL_requires_max_().

PopRequestPowerIrpCompletion

IO_COMPLETION_ROUTINE PopRequestPowerIrpCompletion

static

Definition at line 127 of file power.c.

Referenced by PoRequestPowerIrp().

PopShutdownWorkItem

WORK_QUEUE_ITEM PopShutdownWorkItem

Definition at line 28 of file power.c.

Referenced by NtSetSystemPowerState().

PopSystemPowerDeviceNode

PDEVICE_NODE PopSystemPowerDeviceNode = NULL

Definition at line 25 of file power.c.

Referenced by IopGetSystemPowerDeviceObject(), and PiCallDriverAddDevice().