supportkm.cpp File Reference

#include "../pnppriv.hpp"
#include <wdmguid.h>

Include dependency graph for supportkm.cpp:

Go to the source code of this file.

Functions
VOID	CopyQueryInterfaceToIrpStack (__in PPOWER_THREAD_INTERFACE PowerThreadInterface, __in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS NTAPI	GetStackCapabilities (__in PFX_DRIVER_GLOBALS DriverGlobals, __in MxDeviceObject *DeviceInStack, __in_opt PD3COLD_SUPPORT_INTERFACE D3ColdInterface, __out PSTACK_DEVICE_CAPABILITIES Capabilities)
VOID NTAPI	SetD3ColdSupport (__in PFX_DRIVER_GLOBALS DriverGlobals, __in MxDeviceObject *DeviceInStack, __in PD3COLD_SUPPORT_INTERFACE D3ColdInterface, __in BOOLEAN UseD3Cold)
_Must_inspect_result_ PVOID	GetIoMgrObjectForWorkItemAllocation (VOID)
_Must_inspect_result_ NTSTATUS NTAPI	SendDeviceUsageNotification (__in MxDeviceObject *RelatedDevice, __inout FxIrp *RelatedIrp, __in MxWorkItem *Workitem, __in FxIrp *OriginalIrp, __in BOOLEAN Revert)
NTSTATUS	SendDeviceUsageNotificationWorker (__in MxDeviceObject *RelatedDevice, __inout FxIrp *RelatedIrp, __in FxIrp *OriginalIrp, __in BOOLEAN Revert)
VOID NTAPI	_DeviceUsageNotificationWorkItem (__in MdDeviceObject DeviceObject, __in PVOID Context)

Function Documentation

_DeviceUsageNotificationWorkItem()

VOID NTAPI _DeviceUsageNotificationWorkItem	(	__in MdDeviceObject	DeviceObject,
		__in PVOID	Context
	)

Definition at line 298 of file supportkm.cpp.

{
    FxUsageWorkitemParameters* param;
    NTSTATUS status;
 
    UNREFERENCED_PARAMETER(DeviceObject);
 
    param = (FxUsageWorkitemParameters*) Context;
 
    status = SendDeviceUsageNotificationWorker(param->RelatedDevice,
                                               param->RelatedIrp,
                                               param->OriginalIrp,
                                               param->Revert);
 
    //
    // capture status in notification object
    //
    param->Status = status;
 
    //
    // set event to allow the origial notifcation thread to proceed
    //
    param->Event.Set();
}

CopyQueryInterfaceToIrpStack()

VOID CopyQueryInterfaceToIrpStack	(	__in PPOWER_THREAD_INTERFACE	PowerThreadInterface,
		__in FxIrp *	Irp
	)

Definition at line 32 of file supportkm.cpp.

{
    PIO_STACK_LOCATION stack;
 
    stack = Irp->GetCurrentIrpStackLocation();
 
    RtlCopyMemory(stack->Parameters.QueryInterface.Interface,
        PowerThreadInterface,
        PowerThreadInterface->Interface.Size);
}

Referenced by FxPkgPnp::HandleQueryInterfaceForPowerThread().

GetIoMgrObjectForWorkItemAllocation()

_Must_inspect_result_ PVOID GetIoMgrObjectForWorkItemAllocation

(

VOID

)

Definition at line 191 of file supportkm.cpp.

{
    return (PVOID) FxLibraryGlobals.DriverObject;
}

GetStackCapabilities()

_Must_inspect_result_ NTSTATUS NTAPI GetStackCapabilities	(	__in PFX_DRIVER_GLOBALS	DriverGlobals,
		__in MxDeviceObject *	DeviceInStack,
		__in_opt PD3COLD_SUPPORT_INTERFACE	D3ColdInterface,
		__out PSTACK_DEVICE_CAPABILITIES	Capabilities
	)

Definition at line 49 of file supportkm.cpp.

{
    ULONG i;
    FxAutoIrp irp;
    NTSTATUS status;
 
    ASSERT(Capabilities != NULL);
 
    status = STATUS_INSUFFICIENT_RESOURCES;
 
    //
    // Normally this would be assigned to a local variable on the stack.  Since
    // query caps iteratively moves down the device's tree until it hits the
    // root.  As such, stack usage is consumed quickly.  While this is only one
    // pointer value we are saving, it does eventually add up on very deep stacks.
    //
    DeviceInStack->SetObject(DeviceInStack->GetAttachedDeviceReference());
    if (DeviceInStack->GetObject() == NULL) {
        goto Done;
    }
 
    irp.SetIrp(FxIrp::AllocateIrp(DeviceInStack->GetStackSize()));
    if (irp.GetIrp() == NULL) {
        goto Done;
    }
 
    //
    // Initialize device capabilities.
    //
    RtlZeroMemory(Capabilities, sizeof(STACK_DEVICE_CAPABILITIES));
    Capabilities->DeviceCaps.Size = sizeof(DEVICE_CAPABILITIES);
    Capabilities->DeviceCaps.Version  =  1;
    Capabilities->DeviceCaps.Address  = (ULONG) -1;
    Capabilities->DeviceCaps.UINumber = (ULONG) -1;
 
    //
    // Initialize the Irp.
    //
    irp.SetStatus(STATUS_NOT_SUPPORTED);
 
    irp.ClearNextStack();
    irp.SetMajorFunction(IRP_MJ_PNP);
    irp.SetMinorFunction(IRP_MN_QUERY_CAPABILITIES);
    irp.SetParameterDeviceCapabilities(&Capabilities->DeviceCaps);
 
    status = irp.SendIrpSynchronously(DeviceInStack->GetObject());
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            DriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "Failed to get DEVICE_CAPABILITIES from !devobj %p, %!STATUS!",
            DeviceInStack->GetObject(), status);
        goto Done;
    }
 
    //
    // Invoke the D3cold support interface.  If present, it will tell
    // us specifically which D-states will work for generating wake signals
    // from specific S-states.
    //
    // Earlier versions of WDF didn't make this query, so for compatibility,
    // we only make it now if the driver was built against WDF 1.11 or
    // later.  In truth, this just shifts the failure from initialization
    // time to run time, because the information that we're presumably
    // getting from the BIOS with this interrogation is saying that the
    // code in earlier verisions of WDF would have blindly enabled a device
    // for wake which simply wasn't capable of generating its wake signal
    // from the chosen D-state.  Thus the device would have been put into
    // a low power state and then failed to resume in response to its wake
    // signal.
    //
 
    for (i = 0; i <= PowerSystemHibernate; i++) {
        Capabilities->DeepestWakeableDstate[i] = DeviceWakeDepthMaximum;
    }
 
    if (ARGUMENT_PRESENT(D3ColdInterface) &&
        (D3ColdInterface->GetIdleWakeInfo != NULL) &&
        DriverGlobals->IsVersionGreaterThanOrEqualTo(1,11)) {
 
        DEVICE_WAKE_DEPTH deepestWakeableDstate;
 
        for (i = PowerSystemWorking; i <= PowerSystemHibernate; i++) {
 
            //
            // Failure from D3ColdInterface->GetIdleWakeInfo just means that
            // the bus drivers didn't have any information beyond what can
            // gleaned from the older Query-Capabilities code path.
            //
            // In specific ACPI terms, ACPI will respond to this function with
            // success whenever there is an _SxW object (where x is the sleep
            // state, a value from 0 to 4.)
            //
            // PCI will respond to this interface if ACPI doesn't override its
            // answer and if a parent bus is capable of leaving D0 in S0, and
            // if the PCI device has
            status = D3ColdInterface->GetIdleWakeInfo(
                D3ColdInterface->Context,
                (SYSTEM_POWER_STATE)i,
                &deepestWakeableDstate
                );
 
            if (NT_SUCCESS(status)) {
                Capabilities->DeepestWakeableDstate[i] = deepestWakeableDstate;
            }
        }
    }
 
    status = STATUS_SUCCESS;
 
Done:
    if (DeviceInStack->GetObject() != NULL) {
        DeviceInStack->DereferenceObject();
    }
 
    return status;
}

Referenced by FxPkgPdo::_QueryCapsWorkItem(), FxPkgPdo::PnpQueryCapabilities(), and FxPkgPnp::QueryForCapabilities().

SendDeviceUsageNotification()

_Must_inspect_result_ NTSTATUS NTAPI SendDeviceUsageNotification	(	__in MxDeviceObject *	RelatedDevice,
		__inout FxIrp *	RelatedIrp,
		__in MxWorkItem *	Workitem,
		__in FxIrp *	OriginalIrp,
		__in BOOLEAN	Revert
	)

Definition at line 219 of file supportkm.cpp.

{
    NTSTATUS status;
 
    //
    // use workitem if available
    //
    if (Workitem->GetWorkItem() != NULL) {
        FxUsageWorkitemParameters param;
 
        param.RelatedDevice = RelatedDevice;
        param.RelatedIrp = RelatedIrp;
        param.OriginalIrp = OriginalIrp;
        param.Revert = Revert;
 
        //
        // Kick off to another thread
        //
        Workitem->Enqueue(_DeviceUsageNotificationWorkItem, &param);
 
        //
        // wait for the workitem to finish
        //
        param.Event.EnterCRAndWaitAndLeave();
 
        status = param.Status;
    }
    else {
        status = SendDeviceUsageNotificationWorker(RelatedDevice,
                                                   RelatedIrp,
                                                   OriginalIrp,
                                                   Revert);
    }
 
    return status;
}

Referenced by FxPkgPnp::PnpDeviceUsageNotification().

SendDeviceUsageNotificationWorker()

NTSTATUS SendDeviceUsageNotificationWorker	(	__in MxDeviceObject *	RelatedDevice,
		__inout FxIrp *	RelatedIrp,
		__in FxIrp *	OriginalIrp,
		__in BOOLEAN	Revert
	)

Definition at line 263 of file supportkm.cpp.

{
    MxDeviceObject relatedTopOfStack;
    NTSTATUS status;
 
    relatedTopOfStack.SetObject(RelatedDevice->GetAttachedDeviceReference());
    ASSERT(relatedTopOfStack.GetObject() != NULL);
 
    //
    // Initialize the new IRP with the stack data from the current IRP and
    // and send it to the parent stack.
    //
    RelatedIrp->InitNextStackUsingStack(OriginalIrp);
 
    if (Revert) {
        RelatedIrp->SetParameterUsageNotificationInPath(
            !RelatedIrp->GetNextStackParameterUsageNotificationInPath());
    }
 
    RelatedIrp->SetStatus(STATUS_NOT_SUPPORTED);
 
    status = RelatedIrp->SendIrpSynchronously(relatedTopOfStack.GetObject());
 
    relatedTopOfStack.DereferenceObject();
 
    return status;
}

Referenced by _DeviceUsageNotificationWorkItem(), and SendDeviceUsageNotification().

SetD3ColdSupport()

VOID NTAPI SetD3ColdSupport	(	__in PFX_DRIVER_GLOBALS	DriverGlobals,
		__in MxDeviceObject *	DeviceInStack,
		__in PD3COLD_SUPPORT_INTERFACE	D3ColdInterface,
		__in BOOLEAN	UseD3Cold
	)

Definition at line 174 of file supportkm.cpp.

{
    UNREFERENCED_PARAMETER(DriverGlobals);
    UNREFERENCED_PARAMETER(DeviceInStack);
 
    if (D3ColdInterface->SetD3ColdSupport != NULL) {
        D3ColdInterface->SetD3ColdSupport(D3ColdInterface->Context, UseD3Cold);
    }
}

Referenced by FxPkgPnp::PowerPolicySetS0IdleSettings().