pnpstatemachine.cpp File Reference

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

Include dependency graph for pnpstatemachine.cpp:

Go to the source code of this file.

Macros
#define	VALIDATE_PNP_STATE(_CurrentState, _NewState)   (0)
#define	RESTART_START_ACHIEVED_NAME   L"StartAchieved"
#define	RESTART_START_TIME_NAME   L"StartTime"
#define	RESTART_COUNT_NAME   L"Count"

Functions
	__drv_when (!NT_SUCCESS(return), __drv_arg(ResourcesMatched, _Must_inspect_result_)) NTSTATUS FxPkgPnp

Macro Definition Documentation

RESTART_COUNT_NAME

#define RESTART_COUNT_NAME   L"Count"

Definition at line 4517 of file pnpstatemachine.cpp.

RESTART_START_ACHIEVED_NAME

#define RESTART_START_ACHIEVED_NAME   L"StartAchieved"

Definition at line 4515 of file pnpstatemachine.cpp.

RESTART_START_TIME_NAME

#define RESTART_START_TIME_NAME   L"StartTime"

Definition at line 4516 of file pnpstatemachine.cpp.

VALIDATE_PNP_STATE

#define VALIDATE_PNP_STATE	(		_CurrentState,
			_NewState
	)		(0)

Definition at line 66 of file pnpstatemachine.cpp.

Function Documentation

__drv_when()

__drv_when	(	!	NT_SUCCESSreturn,
		__drv_arg(ResourcesMatched, _Must_inspect_result_)
	)

Definition at line 3476 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    *ResourcesMatched = FALSE;
 
    //
    // FxPnpStateRemoved:
    // Mark the device a not removed.  This is just so that anybody sending
    // a PnP IRP_MN_QUERY_DEVICE_STATE gets a reasonable answer.
    //
    // FxPnpStateFailed, FxPnpStateResourcesChanged:
    // Both of these values can be set to true and cause another start to
    // be sent down the stack.  Reset these values back to false.  If there is
    // a need to set these values, the driver can set them in
    // EvtDevicePrepareHardware.
    //
    m_PnpStateAndCaps.Value &= ~(FxPnpStateRemovedMask |
                                 FxPnpStateFailedMask |
                                 FxPnpStateResourcesChangedMask);
    m_PnpStateAndCaps.Value |= (FxPnpStateRemovedUseDefault |
                                FxPnpStateFailedUseDefault |
                                FxPnpStateResourcesChangedUseDefault);
 
    //
    // This will parse the resources and setup all the WDFINTERRUPT handles
    //
    status = PnpMatchResources();
 
    if (!NT_SUCCESS(status)) {
        *ResourcesMatched = FALSE;
        SetInternalFailure();
        SetPendingPnpIrpStatus(status);
        return status;
    }
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    //
    // Build register resource table
    //
    status = m_Resources->BuildRegisterResourceTable();
    if (!NT_SUCCESS(status)) {
        SetInternalFailure();
        SetPendingPnpIrpStatus(status);
        goto exit;
    }
 
    //
    // Build Port resource table
    //
    status = m_Resources->BuildPortResourceTable();
    if (!NT_SUCCESS(status)) {
        SetInternalFailure();
        SetPendingPnpIrpStatus(status);
        goto exit;
    }
 
    //
    // We keep track if the device has any connection resources,
    // in which case we allow unrestricted access to interrupts
    // regardless of the UmdfDirectHardwareAccess directive.
    //
    status = m_Resources->CheckForConnectionResources();
    if (!NT_SUCCESS(status)) {
        SetInternalFailure();
        SetPendingPnpIrpStatus(status);
        goto exit;
    }
#endif
 
    *ResourcesMatched = TRUE;
 
    m_Device->SetCallbackFlags(
                        FXDEVICE_CALLBACK_IN_PREPARE_HARDWARE
                        );
 
    status = m_DevicePrepareHardware.Invoke(m_Device->GetHandle(),
                                            m_ResourcesRaw->GetHandle(),
                                            m_Resources->GetHandle());
 
    m_Device->ClearCallbackFlags(
                        FXDEVICE_CALLBACK_IN_PREPARE_HARDWARE
                        );
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "EvtDevicePrepareHardware failed %!STATUS!", status);
 
        if (status == STATUS_NOT_SUPPORTED) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "EvtDevicePrepareHardware returned an invalid status "
                "STATUS_NOT_SUPPORTED");
 
            if (GetDriverGlobals()->IsVerificationEnabled(1, 11, OkForDownLevel)) {
                FxVerifierDbgBreakPoint(GetDriverGlobals());
            }
        }
 
        SetInternalFailure();
        SetPendingPnpIrpStatus(status);
        goto exit;
    }
 
    //
    // Now that we have assigned the resources to all the interrupts, figure out
    // the highest synch irql for each interrupt set which shares a spinlock.
    //
    PnpAssignInterruptsSyncIrql();
 
    //
    // Do mode-specific work. For KMDF, there is nothing additional to do.
    //
    status = PnpPrepareHardwareInternal();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "PrepareHardware failed %!STATUS!", status);
 
        SetInternalFailure();
        SetPendingPnpIrpStatus(status);
    }
 
exit:
    return status;
}