/*++ Copyright (c) Microsoft Corporation. All rights reserved. Module Name: WdfDevice.h Environment: user mode NOTE: This header is generated by stubwork. To modify contents, add or remove or tags in the corresponding .x and .y template files. --*/ #pragma once #ifndef WDF_EXTERN_C #ifdef __cplusplus #define WDF_EXTERN_C extern "C" #define WDF_EXTERN_C_START extern "C" { #define WDF_EXTERN_C_END } #else #define WDF_EXTERN_C #define WDF_EXTERN_C_START #define WDF_EXTERN_C_END #endif #endif WDF_EXTERN_C_START #include // begin_wpp enum typedef enum _WDF_DEVICE_STATE_FLAGS { WdfDevStateNP = 0x8000, } WDF_DEVICE_STATE_FLAGS; // end_wpp // begin_wpp enum typedef enum _WDF_DEVICE_PNP_STATE { WdfDevStatePnpInvalid = 0x00, WdfDevStatePnpObjectCreated = 0x100, WdfDevStatePnpCheckForDevicePresence = 0x101, WdfDevStatePnpEjectFailed = 0x102, WdfDevStatePnpEjectHardware = 0x103, WdfDevStatePnpEjectedWaitingForRemove = 0x104, WdfDevStatePnpInit = 0x105, WdfDevStatePnpInitStarting = 0x106, WdfDevStatePnpInitSurpriseRemoved = 0x107, WdfDevStatePnpHardwareAvailable = 0x108, WdfDevStatePnpEnableInterfaces = 0x109, WdfDevStatePnpHardwareAvailablePowerPolicyFailed = 0x10A, WdfDevStatePnpQueryRemoveAskDriver = 0x10B, WdfDevStatePnpQueryRemovePending = 0x10C, WdfDevStatePnpQueryRemoveStaticCheck = 0x10D, WdfDevStatePnpQueriedRemoving = 0x10E, WdfDevStatePnpQueryStopAskDriver = 0x10F, WdfDevStatePnpQueryStopPending = 0x110, WdfDevStatePnpQueryStopStaticCheck = 0x111, WdfDevStatePnpQueryCanceled = 0x112, WdfDevStatePnpRemoved = 0x113, WdfDevStatePnpPdoRemoved = 0x114, WdfDevStatePnpRemovedPdoWait = 0x115, WdfDevStatePnpRemovedPdoSurpriseRemoved = 0x116, WdfDevStatePnpRemovingDisableInterfaces = 0x117, WdfDevStatePnpRestarting = 0x118, WdfDevStatePnpStarted = 0x119, WdfDevStatePnpStartedCancelStop = 0x11A, WdfDevStatePnpStartedCancelRemove = 0x11B, WdfDevStatePnpStartedRemoving = 0x11C, WdfDevStatePnpStartingFromStopped = 0x11D, WdfDevStatePnpStopped = 0x11E, WdfDevStatePnpStoppedWaitForStartCompletion = 0x11F, WdfDevStatePnpStartedStopping = 0x120, WdfDevStatePnpSurpriseRemove = 0x121, WdfDevStatePnpInitQueryRemove = 0x122, WdfDevStatePnpInitQueryRemoveCanceled = 0x123, WdfDevStatePnpFdoRemoved = 0x124, WdfDevStatePnpRemovedWaitForChildren = 0x125, WdfDevStatePnpQueriedSurpriseRemove = 0x126, WdfDevStatePnpSurpriseRemoveIoStarted = 0x127, WdfDevStatePnpFailedPowerDown = 0x128, WdfDevStatePnpFailedIoStarting = 0x129, WdfDevStatePnpFailedOwnHardware = 0x12A, WdfDevStatePnpFailed = 0x12B, WdfDevStatePnpFailedSurpriseRemoved = 0x12C, WdfDevStatePnpFailedStarted = 0x12D, WdfDevStatePnpFailedWaitForRemove = 0x12E, WdfDevStatePnpFailedInit = 0x12F, WdfDevStatePnpPdoInitFailed = 0x130, WdfDevStatePnpRestart = 0x131, WdfDevStatePnpRestartReleaseHardware = 0x132, WdfDevStatePnpRestartHardwareAvailable = 0x133, WdfDevStatePnpPdoRestart = 0x134, WdfDevStatePnpFinal = 0x135, WdfDevStatePnpRemovedChildrenRemoved = 0x136, WdfDevStatePnpQueryRemoveEnsureDeviceAwake = 0x137, WdfDevStatePnpQueryStopEnsureDeviceAwake = 0x138, WdfDevStatePnpFailedPowerPolicyRemoved = 0x139, WdfDevStatePnpNull = 0x13A, } WDF_DEVICE_PNP_STATE, *PWDF_DEVICE_PNP_STATE; // end_wpp // begin_wpp enum typedef enum _WDF_DEVICE_POWER_STATE { WdfDevStatePowerInvalid = 0x00, WdfDevStatePowerObjectCreated = 0x300, WdfDevStatePowerCheckDeviceType = 0x301, WdfDevStatePowerCheckDeviceTypeNP = 0x302 | WdfDevStateNP, WdfDevStatePowerCheckParentState = 0x303, WdfDevStatePowerCheckParentStateNP = 0x304 | WdfDevStateNP, WdfDevStatePowerEnablingWakeAtBus = 0x305, WdfDevStatePowerEnablingWakeAtBusNP = 0x306 | WdfDevStateNP, WdfDevStatePowerD0 = 0x307, WdfDevStatePowerD0NP = 0x308 | WdfDevStateNP, WdfDevStatePowerD0BusWakeOwner = 0x309, WdfDevStatePowerD0BusWakeOwnerNP = 0x30A | WdfDevStateNP, WdfDevStatePowerD0ArmedForWake = 0x30B, WdfDevStatePowerD0ArmedForWakeNP = 0x30C | WdfDevStateNP, WdfDevStatePowerD0DisarmingWakeAtBus = 0x30D, WdfDevStatePowerD0DisarmingWakeAtBusNP = 0x30E | WdfDevStateNP, WdfDevStatePowerD0Starting = 0x30F, WdfDevStatePowerD0StartingConnectInterrupt = 0x310, WdfDevStatePowerD0StartingDmaEnable = 0x311, WdfDevStatePowerD0StartingStartSelfManagedIo = 0x312, WdfDevStatePowerDecideD0State = 0x313, WdfDevStatePowerGotoD3Stopped = 0x314, WdfDevStatePowerStopped = 0x315, WdfDevStatePowerStartingCheckDeviceType = 0x316, WdfDevStatePowerStartingChild = 0x317, WdfDevStatePowerDxDisablingWakeAtBus = 0x318, WdfDevStatePowerDxDisablingWakeAtBusNP = 0x319 | WdfDevStateNP, WdfDevStatePowerGotoDx = 0x31A, WdfDevStatePowerGotoDxNP = 0x31B | WdfDevStateNP, WdfDevStatePowerGotoDxIoStopped = 0x31C, WdfDevStatePowerGotoDxIoStoppedNP = 0x31D | WdfDevStateNP, WdfDevStatePowerGotoDxNPFailed = 0x31E | WdfDevStateNP, WdfDevStatePowerDx = 0x31F, WdfDevStatePowerDxNP = 0x320 | WdfDevStateNP, WdfDevStatePowerGotoDxArmedForWake = 0x321, WdfDevStatePowerGotoDxArmedForWakeNP = 0x322 | WdfDevStateNP, WdfDevStatePowerGotoDxIoStoppedArmedForWake = 0x323, WdfDevStatePowerGotoDxIoStoppedArmedForWakeNP = 0x324 | WdfDevStateNP, WdfDevStatePowerDxArmedForWake = 0x325, WdfDevStatePowerDxArmedForWakeNP = 0x326 | WdfDevStateNP, WdfDevStatePowerCheckParentStateArmedForWake = 0x327, WdfDevStatePowerCheckParentStateArmedForWakeNP = 0x328 | WdfDevStateNP, WdfDevStatePowerWaitForParentArmedForWake = 0x329, WdfDevStatePowerWaitForParentArmedForWakeNP = 0x32A | WdfDevStateNP, WdfDevStatePowerStartSelfManagedIo = 0x32B, WdfDevStatePowerStartSelfManagedIoNP = 0x32C | WdfDevStateNP, WdfDevStatePowerStartSelfManagedIoFailed = 0x32D, WdfDevStatePowerStartSelfManagedIoFailedNP = 0x32E | WdfDevStateNP, WdfDevStatePowerWaitForParent = 0x32F, WdfDevStatePowerWaitForParentNP = 0x330 | WdfDevStateNP, WdfDevStatePowerWakePending = 0x331, WdfDevStatePowerWakePendingNP = 0x332 | WdfDevStateNP, WdfDevStatePowerWaking = 0x333, WdfDevStatePowerWakingNP = 0x334 | WdfDevStateNP, WdfDevStatePowerWakingConnectInterrupt = 0x335, WdfDevStatePowerWakingConnectInterruptNP = 0x336 | WdfDevStateNP, WdfDevStatePowerWakingConnectInterruptFailed = 0x337, WdfDevStatePowerWakingConnectInterruptFailedNP = 0x338 | WdfDevStateNP, WdfDevStatePowerWakingDmaEnable = 0x339, WdfDevStatePowerWakingDmaEnableNP = 0x33A | WdfDevStateNP, WdfDevStatePowerWakingDmaEnableFailed = 0x33B, WdfDevStatePowerWakingDmaEnableFailedNP = 0x33C | WdfDevStateNP, WdfDevStatePowerReportPowerUpFailedDerefParent = 0x33D, WdfDevStatePowerReportPowerUpFailed = 0x33E, WdfDevStatePowerPowerFailedPowerDown = 0x33F, WdfDevStatePowerReportPowerDownFailed = 0x340, WdfDevStatePowerInitialConnectInterruptFailed = 0x341, WdfDevStatePowerInitialDmaEnableFailed = 0x342, WdfDevStatePowerInitialSelfManagedIoFailed = 0x343, WdfDevStatePowerInitialPowerUpFailedDerefParent = 0x344, WdfDevStatePowerInitialPowerUpFailed = 0x345, WdfDevStatePowerDxStoppedDisarmWake = 0x346, WdfDevStatePowerDxStoppedDisarmWakeNP = 0x347 | WdfDevStateNP, WdfDevStatePowerGotoDxStoppedDisableInterruptNP = 0x348 | WdfDevStateNP, WdfDevStatePowerGotoDxStopped = 0x349, WdfDevStatePowerDxStopped = 0x34A, WdfDevStatePowerGotoStopped = 0x34B, WdfDevStatePowerStoppedCompleteDx = 0x34C, WdfDevStatePowerDxStoppedDecideDxState = 0x34D, WdfDevStatePowerDxStoppedArmForWake = 0x34E, WdfDevStatePowerDxStoppedArmForWakeNP = 0x34F | WdfDevStateNP, WdfDevStatePowerFinalPowerDownFailed = 0x350, WdfDevStatePowerFinal = 0x351, WdfDevStatePowerGotoImplicitD3DisarmWakeAtBus = 0x352, WdfDevStatePowerUpFailed = 0x353, WdfDevStatePowerUpFailedDerefParent = 0x354, WdfDevStatePowerGotoDxFailed = 0x355, WdfDevStatePowerGotoDxStoppedDisableInterrupt = 0x356, WdfDevStatePowerUpFailedNP = 0x357 | WdfDevStateNP, WdfDevStatePowerUpFailedDerefParentNP = 0x358 | WdfDevStateNP, WdfDevStatePowerNotifyingD0ExitToWakeInterrupts = 0x359, WdfDevStatePowerNotifyingD0EntryToWakeInterrupts = 0x35A, WdfDevStatePowerNotifyingD0ExitToWakeInterruptsNP = 0x35B | WdfDevStateNP, WdfDevStatePowerNotifyingD0EntryToWakeInterruptsNP = 0x35C | WdfDevStateNP, WdfDevStatePowerInitialPowerUpFailedPowerDown = 0x35D, WdfDevStatePowerUpFailedPowerDown = 0x35E, WdfDevStatePowerUpFailedPowerDownNP = 0x35F | WdfDevStateNP, WdfDevStatePowerInitialSelfManagedIoFailedStarted = 0x360, WdfDevStatePowerStartSelfManagedIoFailedStarted = 0x361, WdfDevStatePowerStartSelfManagedIoFailedStartedNP = 0x362 | WdfDevStateNP, WdfDevStatePowerNull = 0x363, } WDF_DEVICE_POWER_STATE, *PWDF_DEVICE_POWER_STATE; // end_wpp // begin_wpp enum typedef enum _WDF_DEVICE_POWER_POLICY_STATE { WdfDevStatePwrPolInvalid = 0x00, WdfDevStatePwrPolObjectCreated = 0x500, WdfDevStatePwrPolStarting = 0x501, WdfDevStatePwrPolStartingSucceeded = 0x502, WdfDevStatePwrPolStartingFailed = 0x503, WdfDevStatePwrPolStartingDecideS0Wake = 0x504, WdfDevStatePwrPolStartedIdleCapable = 0x505, WdfDevStatePwrPolTimerExpiredNoWake = 0x506, WdfDevStatePwrPolTimerExpiredNoWakeCompletePowerDown = 0x507, WdfDevStatePwrPolWaitingUnarmed = 0x508, WdfDevStatePwrPolWaitingUnarmedQueryIdle = 0x509, WdfDevStatePwrPolS0NoWakePowerUp = 0x50A, WdfDevStatePwrPolS0NoWakeCompletePowerUp = 0x50B, WdfDevStatePwrPolSystemSleepFromDeviceWaitingUnarmed = 0x50C, WdfDevStatePwrPolSystemSleepNeedWake = 0x50D, WdfDevStatePwrPolSystemSleepNeedWakeCompletePowerUp = 0x50E, WdfDevStatePwrPolSystemSleepPowerRequestFailed = 0x50F, WdfDevStatePwrPolCheckPowerPageable = 0x510, WdfDevStatePwrPolSleepingWakeWakeArrived = 0x511, WdfDevStatePwrPolSleepingWakeRevertArmWake = 0x512, WdfDevStatePwrPolSystemAsleepWakeArmed = 0x513, WdfDevStatePwrPolSystemWakeDeviceWakeEnabled = 0x514, WdfDevStatePwrPolSystemWakeDeviceWakeEnabledWakeCanceled = 0x515, WdfDevStatePwrPolSystemWakeDeviceWakeDisarm = 0x516, WdfDevStatePwrPolSystemWakeDeviceWakeTriggered = 0x517, WdfDevStatePwrPolSystemWakeDeviceWakeTriggeredS0 = 0x518, WdfDevStatePwrPolSystemWakeDeviceWokeDisarm = 0x519, WdfDevStatePwrPolSleepingWakeWakeArrivedNP = 0x51A | WdfDevStateNP, WdfDevStatePwrPolSleepingWakeRevertArmWakeNP = 0x51B | WdfDevStateNP, WdfDevStatePwrPolSleepingWakePowerDownFailed = 0x51C, WdfDevStatePwrPolSleepingWakePowerDownFailedWakeCanceled = 0x51D, WdfDevStatePwrPolSystemAsleepWakeArmedNP = 0x51E | WdfDevStateNP, WdfDevStatePwrPolSystemWakeDeviceWakeEnabledNP = 0x51F | WdfDevStateNP, WdfDevStatePwrPolSystemWakeDeviceWakeEnabledWakeCanceledNP = 0x520 | WdfDevStateNP, WdfDevStatePwrPolSystemWakeDeviceWakeDisarmNP = 0x521 | WdfDevStateNP, WdfDevStatePwrPolSystemWakeDeviceWakeTriggeredNP = 0x522 | WdfDevStateNP, WdfDevStatePwrPolSystemWakeDeviceWakeTriggeredS0NP = 0x523 | WdfDevStateNP, WdfDevStatePwrPolSystemWakeDeviceWokeDisarmNP = 0x524 | WdfDevStateNP, WdfDevStatePwrPolSystemWakeDeviceWakeCompletePowerUp = 0x525, WdfDevStatePwrPolSleeping = 0x526, WdfDevStatePwrPolSleepingNoWakePowerDown = 0x527, WdfDevStatePwrPolSleepingNoWakeCompletePowerDown = 0x528, WdfDevStatePwrPolSleepingNoWakeDxRequestFailed = 0x529, WdfDevStatePwrPolSleepingWakePowerDown = 0x52A, WdfDevStatePwrPolSleepingSendWake = 0x52B, WdfDevStatePwrPolSystemAsleepNoWake = 0x52C, WdfDevStatePwrPolSystemWakeDeviceWakeDisabled = 0x52D, WdfDevStatePwrPolSystemWakeDeviceToD0 = 0x52E, WdfDevStatePwrPolSystemWakeDeviceToD0CompletePowerUp = 0x52F, WdfDevStatePwrPolSystemWakeQueryIdle = 0x530, WdfDevStatePwrPolStartedWakeCapable = 0x531, WdfDevStatePwrPolTimerExpiredDecideUsbSS = 0x532, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDown = 0x533, WdfDevStatePwrPolTimerExpiredWakeCapableSendWake = 0x534, WdfDevStatePwrPolTimerExpiredWakeCapableUsbSS = 0x535, WdfDevStatePwrPolTimerExpiredWakeCapableWakeArrived = 0x536, WdfDevStatePwrPolTimerExpiredWakeCapableCancelWake = 0x537, WdfDevStatePwrPolTimerExpiredWakeCapableWakeCanceled = 0x538, WdfDevStatePwrPolTimerExpiredWakeCapableCleanup = 0x539, WdfDevStatePwrPolTimerExpiredWakeCapableDxAllocFailed = 0x53A, WdfDevStatePwrPolTimerExpiredWakeCompletedPowerDown = 0x53B, WdfDevStatePwrPolTimerExpiredWakeCompletedPowerUp = 0x53C, WdfDevStatePwrPolWaitingArmedUsbSS = 0x53D, WdfDevStatePwrPolWaitingArmed = 0x53E, WdfDevStatePwrPolWaitingArmedQueryIdle = 0x53F, WdfDevStatePwrPolIoPresentArmed = 0x540, WdfDevStatePwrPolIoPresentArmedWakeCanceled = 0x541, WdfDevStatePwrPolS0WakeDisarm = 0x542, WdfDevStatePwrPolS0WakeCompletePowerUp = 0x543, WdfDevStatePwrPolTimerExpiredWakeSucceeded = 0x544, WdfDevStatePwrPolTimerExpiredWakeCompletedDisarm = 0x545, WdfDevStatePwrPolTimerExpiredWakeCapableWakeSucceeded = 0x546, WdfDevStatePwrPolTimerExpiredWakeCapableWakeFailed = 0x547, WdfDevStatePwrPolWakeFailedUsbSS = 0x548, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedCancelWake = 0x549, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedWakeCanceled = 0x54A, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedUsbSS = 0x54B, WdfDevStatePwrPolCancelingWakeForSystemSleep = 0x54C, WdfDevStatePwrPolCancelingWakeForSystemSleepWakeCanceled = 0x54D, WdfDevStatePwrPolDisarmingWakeForSystemSleepCompletePowerUp = 0x54E, WdfDevStatePwrPolPowerUpForSystemSleepFailed = 0x54F, WdfDevStatePwrPolWokeFromS0UsbSS = 0x550, WdfDevStatePwrPolWokeFromS0 = 0x551, WdfDevStatePwrPolWokeFromS0NotifyDriver = 0x552, WdfDevStatePwrPolStoppingResetDevice = 0x553, WdfDevStatePwrPolStoppingResetDeviceCompletePowerUp = 0x554, WdfDevStatePwrPolStoppingResetDeviceFailed = 0x555, WdfDevStatePwrPolStoppingD0 = 0x556, WdfDevStatePwrPolStoppingD0Failed = 0x557, WdfDevStatePwrPolStoppingDisarmWake = 0x558, WdfDevStatePwrPolStoppingDisarmWakeCancelWake = 0x559, WdfDevStatePwrPolStoppingDisarmWakeWakeCanceled = 0x55A, WdfDevStatePwrPolStopping = 0x55B, WdfDevStatePwrPolStoppingFailed = 0x55C, WdfDevStatePwrPolStoppingSendStatus = 0x55D, WdfDevStatePwrPolStoppingCancelTimer = 0x55E, WdfDevStatePwrPolStoppingWaitForIdleTimeout = 0x55F, WdfDevStatePwrPolStoppingCancelUsbSS = 0x560, WdfDevStatePwrPolStoppingWaitForUsbSSCompletion = 0x561, WdfDevStatePwrPolStoppingCancelWake = 0x562, WdfDevStatePwrPolStopped = 0x563, WdfDevStatePwrPolCancelUsbSS = 0x564, WdfDevStatePwrPolStarted = 0x565, WdfDevStatePwrPolStartedCancelTimer = 0x566, WdfDevStatePwrPolStartedWaitForIdleTimeout = 0x567, WdfDevStatePwrPolStartedWakeCapableCancelTimerForSleep = 0x568, WdfDevStatePwrPolStartedWakeCapableWaitForIdleTimeout = 0x569, WdfDevStatePwrPolStartedWakeCapableSleepingUsbSS = 0x56A, WdfDevStatePwrPolStartedIdleCapableCancelTimerForSleep = 0x56B, WdfDevStatePwrPolStartedIdleCapableWaitForIdleTimeout = 0x56C, WdfDevStatePwrPolDeviceD0PowerRequestFailed = 0x56D, WdfDevStatePwrPolDevicePowerRequestFailed = 0x56E, WdfDevStatePwrPolGotoDx = 0x56F, WdfDevStatePwrPolGotoDxInDx = 0x570, WdfDevStatePwrPolDx = 0x571, WdfDevStatePwrPolGotoD0 = 0x572, WdfDevStatePwrPolGotoD0InD0 = 0x573, WdfDevStatePwrPolFinal = 0x574, WdfDevStatePwrPolSleepingPowerDownNotProcessed = 0x575, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownNotProcessed = 0x576, WdfDevStatePwrPolTimerExpiredNoWakePowerDownNotProcessed = 0x577, WdfDevStatePwrPolTimerExpiredNoWakePoweredDownDisableIdleTimer = 0x578, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown = 0x579, WdfDevStatePwrPolStoppingPoweringUp = 0x57A, WdfDevStatePwrPolStoppingPoweringDown = 0x57B, WdfDevStatePwrPolPowerUpForSystemSleepNotSeen = 0x57C, WdfDevStatePwrPolWaitingArmedStoppingCancelUsbSS = 0x57D, WdfDevStatePwrPolWaitingArmedWakeFailedCancelUsbSS = 0x57E, WdfDevStatePwrPolWaitingArmedIoPresentCancelUsbSS = 0x57F, WdfDevStatePwrPolWaitingArmedWakeSucceededCancelUsbSS = 0x580, WdfDevStatePwrPolCancelingUsbSSForSystemSleep = 0x581, WdfDevStatePwrPolStoppingD0CancelUsbSS = 0x582, WdfDevStatePwrPolStartingPoweredUp = 0x583, WdfDevStatePwrPolIdleCapableDeviceIdle = 0x584, WdfDevStatePwrPolDeviceIdleReturnToActive = 0x585, WdfDevStatePwrPolDeviceIdleSleeping = 0x586, WdfDevStatePwrPolDeviceIdleStopping = 0x587, WdfDevStatePwrPolTimerExpiredNoWakeUndoPowerDown = 0x588, WdfDevStatePwrPolWakeCapableDeviceIdle = 0x589, WdfDevStatePwrPolWakeCapableUsbSSCompleted = 0x58A, WdfDevStatePwrPolTimerExpiredWakeCapableUndoPowerDown = 0x58B, WdfDevStatePwrPolTimerExpiredWakeCompletedHardwareStarted = 0x58C, WdfDevStatePwrPolStoppedRemoving = 0x58D, WdfDevStatePwrPolRemoved = 0x58E, WdfDevStatePwrPolRestarting = 0x58F, WdfDevStatePwrPolRestartingFailed = 0x590, WdfDevStatePwrPolStartingPoweredUpFailed = 0x591, WdfDevStatePwrPolTimerExpiredNoWakeReturnToActive = 0x592, WdfDevStatePwrPolWaitingArmedWakeInterruptFired = 0x593, WdfDevStatePwrPolSystemWakeDeviceWakeInterruptFired = 0x594, WdfDevStatePwrPolSystemWakeDeviceWakeInterruptFiredNP = 0x595 | WdfDevStateNP, WdfDevStatePwrPolTimerExpiredWakeCapableWakeInterruptArrived = 0x596, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedWakeInterruptArrived = 0x597, WdfDevStatePwrPolWaitingArmedWakeInterruptFiredDuringPowerDown = 0x598, WdfDevStatePwrPolNull = 0x599, } WDF_DEVICE_POWER_POLICY_STATE, *PWDF_DEVICE_POWER_POLICY_STATE; // end_wpp typedef enum _WDF_STATE_NOTIFICATION_TYPE { StateNotificationInvalid = 0x0000, StateNotificationEnterState = 0x0001, StateNotificationPostProcessState = 0x0002, StateNotificationLeaveState = 0x0004, StateNotificationAllStates = StateNotificationEnterState | StateNotificationPostProcessState | StateNotificationLeaveState, } WDF_STATE_NOTIFICATION_TYPE; typedef enum _WDF_POWER_POLICY_S0_IDLE_CAPABILITIES { IdleCapsInvalid = 0, IdleCannotWakeFromS0, IdleCanWakeFromS0, IdleUsbSelectiveSuspend, } WDF_POWER_POLICY_S0_IDLE_CAPABILITIES; typedef enum _WDF_POWER_POLICY_S0_IDLE_USER_CONTROL { IdleUserControlInvalid = 0, IdleDoNotAllowUserControl, IdleAllowUserControl, } WDF_POWER_POLICY_S0_IDLE_USER_CONTROL; typedef enum _WDF_POWER_POLICY_IDLE_TIMEOUT_CONSTANTS { IdleTimeoutDefaultConstant = 0, } WDF_POWER_POLICY_IDLE_TIMEOUT_CONSTANTS; typedef enum _WDF_POWER_POLICY_SX_WAKE_USER_CONTROL { WakeUserControlInvalid = 0, WakeDoNotAllowUserControl, WakeAllowUserControl, } WDF_POWER_POLICY_SX_WAKE_USER_CONTROL; typedef enum _WDF_POWER_DEVICE_STATE { WdfPowerDeviceInvalid = 0, WdfPowerDeviceD0, WdfPowerDeviceD1, WdfPowerDeviceD2, WdfPowerDeviceD3, WdfPowerDeviceD3Final, WdfPowerDevicePrepareForHibernation, WdfPowerDeviceMaximum, } WDF_POWER_DEVICE_STATE, *PWDF_POWER_DEVICE_STATE; typedef enum _WDF_DEVICE_HWACCESS_TARGET_TYPE { WdfDeviceHwAccessTargetTypeInvalid = 0, WdfDeviceHwAccessTargetTypeRegister, WdfDeviceHwAccessTargetTypeRegisterBuffer, WdfDeviceHwAccessTargetTypePort, WdfDeviceHwAccessTargetTypePortBuffer, WdfDeviceHwAccessTargetTypeMaximum, } WDF_DEVICE_HWACCESS_TARGET_TYPE, *PWDF_DEVICE_HWACCESS_TARGET_TYPE; typedef enum _WDF_DEVICE_HWACCESS_TARGET_SIZE { WdfDeviceHwAccessTargetSizeInvalid = 0, WdfDeviceHwAccessTargetSizeUchar, WdfDeviceHwAccessTargetSizeUshort, WdfDeviceHwAccessTargetSizeUlong, WdfDeviceHwAccessTargetSizeUlong64, WdfDeviceHwAccessTargetSizeMaximum, } WDF_DEVICE_HWACCESS_TARGET_SIZE, *PWDF_DEVICE_HWACCESS_TARGET_SIZE; typedef enum _WDF_DISPATCH_IRP_TO_IO_QUEUE_FLAGS { WDF_DISPATCH_IRP_TO_IO_QUEUE_NO_FLAGS = 0x00000000, WDF_DISPATCH_IRP_TO_IO_QUEUE_INVOKE_INCALLERCTX_CALLBACK = 0x00000001, WDF_DISPATCH_IRP_TO_IO_QUEUE_PREPROCESSED_IRP = 0x00000002, } WDF_DISPATCH_IRP_TO_IO_QUEUE_FLAGS; typedef enum _WDF_SPECIAL_FILE_TYPE { WdfSpecialFileUndefined = 0, WdfSpecialFilePaging = 1, WdfSpecialFileHibernation, WdfSpecialFileDump, WdfSpecialFileBoot, WdfSpecialFileMax, } WDF_SPECIAL_FILE_TYPE, *PWDF_SPECIAL_FILE_TYPE; typedef enum _WDF_DEVICE_IO_TYPE { WdfDeviceIoUndefined = 0, WdfDeviceIoNeither, WdfDeviceIoBuffered, WdfDeviceIoDirect, WdfDeviceIoBufferedOrDirect = 4, WdfDeviceIoMaximum, } WDF_DEVICE_IO_TYPE, *PWDF_DEVICE_IO_TYPE; typedef enum _WDF_FILEOBJECT_CLASS { WdfFileObjectInvalid = 0, WdfFileObjectNotRequired = 1, WdfFileObjectWdfCanUseFsContext = 2, WdfFileObjectWdfCanUseFsContext2 = 3, WdfFileObjectWdfCannotUseFsContexts = 4, WdfFileObjectCanBeOptional = 0x80000000, } WDF_FILEOBJECT_CLASS, *PWDF_FILEOBJECT_CLASS; typedef enum _WDF_DEVICE_FAILED_ACTION { WdfDeviceFailedUndefined = 0, WdfDeviceFailedAttemptRestart, WdfDeviceFailedNoRestart, } WDF_DEVICE_FAILED_ACTION; typedef enum _WDF_RELEASE_HARDWARE_ORDER_ON_FAILURE { WdfReleaseHardwareOrderOnFailureInvalid = 0, WdfReleaseHardwareOrderOnFailureEarly, WdfReleaseHardwareOrderOnFailureAfterDescendants, } WDF_RELEASE_HARDWARE_ORDER_ON_FAILURE, *PWDF_RELEASE_HARDWARE_ORDER_ON_FAILURE; typedef enum _WDF_EVENT_TYPE { WdfEventReserved = 0, WdfEventBroadcast = 1, WdfEventMaximum, } WDF_EVENT_TYPE; #define WDF_S0_IDLE_ENABLED_VALUE_NAME L"IdleInWorkingState" #define WDF_SX_WAKE_ENABLED_VALUE_NAME L"WakeFromSleepState" #define WDF_S0_IDLE_DEFAULT_VALUE_NAME L"WdfDefaultIdleInWorkingState" #define WDF_SX_WAKE_DEFAULT_VALUE_NAME L"WdfDefaultWakeFromSleepState" // // Declare empty definitions so that they may be referenced by // routines before they are defined. // typedef enum _WDF_REQUEST_TYPE WDF_REQUEST_TYPE; typedef _Function_class_(EVT_WDF_DEVICE_FILE_CREATE) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_FILE_CREATE( _In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDFFILEOBJECT FileObject ); typedef EVT_WDF_DEVICE_FILE_CREATE *PFN_WDF_DEVICE_FILE_CREATE; typedef _Function_class_(EVT_WDF_FILE_CLOSE) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_FILE_CLOSE( _In_ WDFFILEOBJECT FileObject ); typedef EVT_WDF_FILE_CLOSE *PFN_WDF_FILE_CLOSE; typedef _Function_class_(EVT_WDF_FILE_CLEANUP) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_FILE_CLEANUP( _In_ WDFFILEOBJECT FileObject ); typedef EVT_WDF_FILE_CLEANUP *PFN_WDF_FILE_CLEANUP; typedef struct _WDF_FILEOBJECT_CONFIG { // // Size of this structure in bytes // ULONG Size; // // Event callback for create requests // PFN_WDF_DEVICE_FILE_CREATE EvtDeviceFileCreate; // // Event callback for close requests // PFN_WDF_FILE_CLOSE EvtFileClose; // // Event callback for cleanup requests // PFN_WDF_FILE_CLEANUP EvtFileCleanup; // // If WdfTrue, create/cleanup/close file object related requests will be // sent down the stack. // // If WdfFalse, create/cleanup/close will be completed at this location in // the device stack. // // If WdfDefault, behavior depends on device type // FDO, PDO, Control: use the WdfFalse behavior // Filter: use the WdfTrue behavior // WDF_TRI_STATE AutoForwardCleanupClose; // // Specify whether framework should create WDFFILEOBJECT and also // whether it can FsContexts fields in the WDM fileobject to store // WDFFILEOBJECT so that it can avoid table look up and improve perf. // WDF_FILEOBJECT_CLASS FileObjectClass; } WDF_FILEOBJECT_CONFIG, *PWDF_FILEOBJECT_CONFIG; VOID FORCEINLINE WDF_FILEOBJECT_CONFIG_INIT( _Out_ PWDF_FILEOBJECT_CONFIG FileEventCallbacks, _In_opt_ PFN_WDF_DEVICE_FILE_CREATE EvtDeviceFileCreate, _In_opt_ PFN_WDF_FILE_CLOSE EvtFileClose, _In_opt_ PFN_WDF_FILE_CLEANUP EvtFileCleanup ) { FileEventCallbacks->Size = sizeof(WDF_FILEOBJECT_CONFIG); FileEventCallbacks->EvtDeviceFileCreate = EvtDeviceFileCreate; FileEventCallbacks->EvtFileClose = EvtFileClose; FileEventCallbacks->EvtFileCleanup = EvtFileCleanup; FileEventCallbacks->FileObjectClass = WdfFileObjectWdfCannotUseFsContexts; FileEventCallbacks->AutoForwardCleanupClose = WdfUseDefault; } typedef struct _WDF_DEVICE_PNP_NOTIFICATION_DATA { // // Type of data // WDF_STATE_NOTIFICATION_TYPE Type; union { struct { // // The current state that is about to be exited // WDF_DEVICE_PNP_STATE CurrentState; // // The new state that is about to be entered // WDF_DEVICE_PNP_STATE NewState; } EnterState; struct { // // The current state // WDF_DEVICE_PNP_STATE CurrentState; } PostProcessState; struct { // // The current state that is about to be exitted // WDF_DEVICE_PNP_STATE CurrentState; // // The state that is about to be entered // WDF_DEVICE_PNP_STATE NewState; } LeaveState; } Data; } WDF_DEVICE_PNP_NOTIFICATION_DATA; typedef const WDF_DEVICE_PNP_NOTIFICATION_DATA* PCWDF_DEVICE_PNP_NOTIFICATION_DATA; typedef struct _WDF_DEVICE_POWER_NOTIFICATION_DATA { // // Type of data // WDF_STATE_NOTIFICATION_TYPE Type; union { struct { // // The current state that is about to be exitted // WDF_DEVICE_POWER_STATE CurrentState; // // The new state that is about to be entered // WDF_DEVICE_POWER_STATE NewState; } EnterState; struct { // // The current state // WDF_DEVICE_POWER_STATE CurrentState; } PostProcessState; struct { // // The current state that is about to be exitted // WDF_DEVICE_POWER_STATE CurrentState; // // The state that is about to be entered // WDF_DEVICE_POWER_STATE NewState; } LeaveState; } Data; } WDF_DEVICE_POWER_NOTIFICATION_DATA; typedef const WDF_DEVICE_POWER_NOTIFICATION_DATA* PCWDF_DEVICE_POWER_NOTIFICATION_DATA; typedef struct _WDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA { // // Type of data // WDF_STATE_NOTIFICATION_TYPE Type; union { struct { // // The current state that is about to be exitted // WDF_DEVICE_POWER_POLICY_STATE CurrentState; // // The new state that is about to be entered // WDF_DEVICE_POWER_POLICY_STATE NewState; } EnterState; struct { // // The current state // WDF_DEVICE_POWER_POLICY_STATE CurrentState; } PostProcessState; struct { // // The current state that is about to be exitted // WDF_DEVICE_POWER_POLICY_STATE CurrentState; // // The state that is about to be entered // WDF_DEVICE_POWER_POLICY_STATE NewState; } LeaveState; } Data; } WDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA; typedef const WDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA* PCWDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA; typedef _Function_class_(EVT_WDF_DEVICE_PNP_STATE_CHANGE_NOTIFICATION) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_PNP_STATE_CHANGE_NOTIFICATION( _In_ WDFDEVICE Device, _In_ PCWDF_DEVICE_PNP_NOTIFICATION_DATA NotificationData ); typedef EVT_WDF_DEVICE_PNP_STATE_CHANGE_NOTIFICATION *PFN_WDF_DEVICE_PNP_STATE_CHANGE_NOTIFICATION; typedef _Function_class_(EVT_WDF_DEVICE_POWER_STATE_CHANGE_NOTIFICATION) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_POWER_STATE_CHANGE_NOTIFICATION( _In_ WDFDEVICE Device, _In_ PCWDF_DEVICE_POWER_NOTIFICATION_DATA NotificationData ); typedef EVT_WDF_DEVICE_POWER_STATE_CHANGE_NOTIFICATION *PFN_WDF_DEVICE_POWER_STATE_CHANGE_NOTIFICATION; typedef _Function_class_(EVT_WDF_DEVICE_POWER_POLICY_STATE_CHANGE_NOTIFICATION) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_POWER_POLICY_STATE_CHANGE_NOTIFICATION( _In_ WDFDEVICE Device, _In_ PCWDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA NotificationData ); typedef EVT_WDF_DEVICE_POWER_POLICY_STATE_CHANGE_NOTIFICATION *PFN_WDF_DEVICE_POWER_POLICY_STATE_CHANGE_NOTIFICATION; #define IdleTimeoutDefaultValue ((ULONG) IdleTimeoutDefaultConstant) typedef _Function_class_(EVT_WDF_DEVICE_D0_ENTRY) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_D0_ENTRY( _In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE PreviousState ); typedef EVT_WDF_DEVICE_D0_ENTRY *PFN_WDF_DEVICE_D0_ENTRY; typedef _Function_class_(EVT_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED( _In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE PreviousState ); typedef EVT_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED *PFN_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED; typedef _Function_class_(EVT_WDF_DEVICE_D0_EXIT) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_D0_EXIT( _In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE TargetState ); typedef EVT_WDF_DEVICE_D0_EXIT *PFN_WDF_DEVICE_D0_EXIT; typedef _Function_class_(EVT_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED( _In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE TargetState ); typedef EVT_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED *PFN_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED; typedef _Function_class_(EVT_WDF_DEVICE_PREPARE_HARDWARE) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_PREPARE_HARDWARE( _In_ WDFDEVICE Device, _In_ WDFCMRESLIST ResourcesRaw, _In_ WDFCMRESLIST ResourcesTranslated ); typedef EVT_WDF_DEVICE_PREPARE_HARDWARE *PFN_WDF_DEVICE_PREPARE_HARDWARE; typedef _Function_class_(EVT_WDF_DEVICE_RELEASE_HARDWARE) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_RELEASE_HARDWARE( _In_ WDFDEVICE Device, _In_ WDFCMRESLIST ResourcesTranslated ); typedef EVT_WDF_DEVICE_RELEASE_HARDWARE *PFN_WDF_DEVICE_RELEASE_HARDWARE; typedef _Function_class_(EVT_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP *PFN_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP; typedef _Function_class_(EVT_WDF_DEVICE_SELF_MANAGED_IO_FLUSH) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_SELF_MANAGED_IO_FLUSH( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_SELF_MANAGED_IO_FLUSH *PFN_WDF_DEVICE_SELF_MANAGED_IO_FLUSH; typedef _Function_class_(EVT_WDF_DEVICE_SELF_MANAGED_IO_INIT) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_SELF_MANAGED_IO_INIT( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_SELF_MANAGED_IO_INIT *PFN_WDF_DEVICE_SELF_MANAGED_IO_INIT; typedef _Function_class_(EVT_WDF_DEVICE_SELF_MANAGED_IO_SUSPEND) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_SELF_MANAGED_IO_SUSPEND( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_SELF_MANAGED_IO_SUSPEND *PFN_WDF_DEVICE_SELF_MANAGED_IO_SUSPEND; typedef _Function_class_(EVT_WDF_DEVICE_SELF_MANAGED_IO_RESTART) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_SELF_MANAGED_IO_RESTART( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_SELF_MANAGED_IO_RESTART *PFN_WDF_DEVICE_SELF_MANAGED_IO_RESTART; typedef _Function_class_(EVT_WDF_DEVICE_QUERY_STOP) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_QUERY_STOP( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_QUERY_STOP *PFN_WDF_DEVICE_QUERY_STOP; typedef _Function_class_(EVT_WDF_DEVICE_QUERY_REMOVE) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_QUERY_REMOVE( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_QUERY_REMOVE *PFN_WDF_DEVICE_QUERY_REMOVE; typedef _Function_class_(EVT_WDF_DEVICE_SURPRISE_REMOVAL) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_SURPRISE_REMOVAL( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_SURPRISE_REMOVAL *PFN_WDF_DEVICE_SURPRISE_REMOVAL; typedef _Function_class_(EVT_WDF_DEVICE_USAGE_NOTIFICATION) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_USAGE_NOTIFICATION( _In_ WDFDEVICE Device, _In_ WDF_SPECIAL_FILE_TYPE NotificationType, _In_ BOOLEAN IsInNotificationPath ); typedef EVT_WDF_DEVICE_USAGE_NOTIFICATION *PFN_WDF_DEVICE_USAGE_NOTIFICATION; typedef _Function_class_(EVT_WDF_DEVICE_USAGE_NOTIFICATION_EX) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_USAGE_NOTIFICATION_EX( _In_ WDFDEVICE Device, _In_ WDF_SPECIAL_FILE_TYPE NotificationType, _In_ BOOLEAN IsInNotificationPath ); typedef EVT_WDF_DEVICE_USAGE_NOTIFICATION_EX *PFN_WDF_DEVICE_USAGE_NOTIFICATION_EX; typedef _Function_class_(EVT_WDF_DEVICE_RELATIONS_QUERY) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_RELATIONS_QUERY( _In_ WDFDEVICE Device, _In_ DEVICE_RELATION_TYPE RelationType ); typedef EVT_WDF_DEVICE_RELATIONS_QUERY *PFN_WDF_DEVICE_RELATIONS_QUERY; typedef _Function_class_(EVT_WDF_DEVICE_ARM_WAKE_FROM_S0) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_ARM_WAKE_FROM_S0( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_ARM_WAKE_FROM_S0 *PFN_WDF_DEVICE_ARM_WAKE_FROM_S0; typedef _Function_class_(EVT_WDF_DEVICE_ARM_WAKE_FROM_SX) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_ARM_WAKE_FROM_SX( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_ARM_WAKE_FROM_SX *PFN_WDF_DEVICE_ARM_WAKE_FROM_SX; typedef _Function_class_(EVT_WDF_DEVICE_ARM_WAKE_FROM_SX_WITH_REASON) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDF_DEVICE_ARM_WAKE_FROM_SX_WITH_REASON( _In_ WDFDEVICE Device, _In_ BOOLEAN DeviceWakeEnabled, _In_ BOOLEAN ChildrenArmedForWake ); typedef EVT_WDF_DEVICE_ARM_WAKE_FROM_SX_WITH_REASON *PFN_WDF_DEVICE_ARM_WAKE_FROM_SX_WITH_REASON; typedef _Function_class_(EVT_WDF_DEVICE_DISARM_WAKE_FROM_S0) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_DISARM_WAKE_FROM_S0( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_DISARM_WAKE_FROM_S0 *PFN_WDF_DEVICE_DISARM_WAKE_FROM_S0; typedef _Function_class_(EVT_WDF_DEVICE_DISARM_WAKE_FROM_SX) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_DISARM_WAKE_FROM_SX( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_DISARM_WAKE_FROM_SX *PFN_WDF_DEVICE_DISARM_WAKE_FROM_SX; typedef _Function_class_(EVT_WDF_DEVICE_WAKE_FROM_S0_TRIGGERED) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_WAKE_FROM_S0_TRIGGERED( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_WAKE_FROM_S0_TRIGGERED *PFN_WDF_DEVICE_WAKE_FROM_S0_TRIGGERED; typedef _Function_class_(EVT_WDF_DEVICE_WAKE_FROM_SX_TRIGGERED) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDF_DEVICE_WAKE_FROM_SX_TRIGGERED( _In_ WDFDEVICE Device ); typedef EVT_WDF_DEVICE_WAKE_FROM_SX_TRIGGERED *PFN_WDF_DEVICE_WAKE_FROM_SX_TRIGGERED; typedef struct _WDF_PNPPOWER_EVENT_CALLBACKS { // // Size of this structure in bytes // ULONG Size; PFN_WDF_DEVICE_D0_ENTRY EvtDeviceD0Entry; PFN_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED EvtDeviceD0EntryPostInterruptsEnabled; PFN_WDF_DEVICE_D0_EXIT EvtDeviceD0Exit; PFN_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED EvtDeviceD0ExitPreInterruptsDisabled; PFN_WDF_DEVICE_PREPARE_HARDWARE EvtDevicePrepareHardware; PFN_WDF_DEVICE_RELEASE_HARDWARE EvtDeviceReleaseHardware; PFN_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP EvtDeviceSelfManagedIoCleanup; PFN_WDF_DEVICE_SELF_MANAGED_IO_FLUSH EvtDeviceSelfManagedIoFlush; PFN_WDF_DEVICE_SELF_MANAGED_IO_INIT EvtDeviceSelfManagedIoInit; PFN_WDF_DEVICE_SELF_MANAGED_IO_SUSPEND EvtDeviceSelfManagedIoSuspend; PFN_WDF_DEVICE_SELF_MANAGED_IO_RESTART EvtDeviceSelfManagedIoRestart; PFN_WDF_DEVICE_SURPRISE_REMOVAL EvtDeviceSurpriseRemoval; PFN_WDF_DEVICE_QUERY_REMOVE EvtDeviceQueryRemove; PFN_WDF_DEVICE_QUERY_STOP EvtDeviceQueryStop; PFN_WDF_DEVICE_USAGE_NOTIFICATION EvtDeviceUsageNotification; PFN_WDF_DEVICE_RELATIONS_QUERY EvtDeviceRelationsQuery; PFN_WDF_DEVICE_USAGE_NOTIFICATION_EX EvtDeviceUsageNotificationEx; } WDF_PNPPOWER_EVENT_CALLBACKS, *PWDF_PNPPOWER_EVENT_CALLBACKS; typedef struct _WDF_POWER_POLICY_EVENT_CALLBACKS { // // Size of this structure in bytes // ULONG Size; PFN_WDF_DEVICE_ARM_WAKE_FROM_S0 EvtDeviceArmWakeFromS0; PFN_WDF_DEVICE_DISARM_WAKE_FROM_S0 EvtDeviceDisarmWakeFromS0; PFN_WDF_DEVICE_WAKE_FROM_S0_TRIGGERED EvtDeviceWakeFromS0Triggered; PFN_WDF_DEVICE_ARM_WAKE_FROM_SX EvtDeviceArmWakeFromSx; PFN_WDF_DEVICE_DISARM_WAKE_FROM_SX EvtDeviceDisarmWakeFromSx; PFN_WDF_DEVICE_WAKE_FROM_SX_TRIGGERED EvtDeviceWakeFromSxTriggered; PFN_WDF_DEVICE_ARM_WAKE_FROM_SX_WITH_REASON EvtDeviceArmWakeFromSxWithReason; } WDF_POWER_POLICY_EVENT_CALLBACKS, *PWDF_POWER_POLICY_EVENT_CALLBACKS; VOID FORCEINLINE WDF_POWER_POLICY_EVENT_CALLBACKS_INIT( _Out_ PWDF_POWER_POLICY_EVENT_CALLBACKS Callbacks ) { RtlZeroMemory(Callbacks, sizeof(WDF_POWER_POLICY_EVENT_CALLBACKS)); Callbacks->Size = sizeof(WDF_POWER_POLICY_EVENT_CALLBACKS); } VOID FORCEINLINE WDF_PNPPOWER_EVENT_CALLBACKS_INIT( _Out_ PWDF_PNPPOWER_EVENT_CALLBACKS Callbacks ) { RtlZeroMemory(Callbacks, sizeof(WDF_PNPPOWER_EVENT_CALLBACKS)); Callbacks->Size = sizeof(WDF_PNPPOWER_EVENT_CALLBACKS); } ULONG FORCEINLINE WdfDevStateNormalize( _In_ ULONG State ) { return State & ~WdfDevStateNP; } BOOLEAN FORCEINLINE WdfDevStateIsNP( _In_ ULONG State ) { return (State & WdfDevStateNP) ? TRUE : FALSE; } typedef enum _WDF_POWER_POLICY_IDLE_TIMEOUT_TYPE { DriverManagedIdleTimeout = 0, SystemManagedIdleTimeout = 1, SystemManagedIdleTimeoutWithHint = 2 } WDF_POWER_POLICY_IDLE_TIMEOUT_TYPE, *PWDF_POWER_POLICY_IDLE_TIMEOUT_TYPE; typedef struct _WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS { // // Size of this structure in bytes // ULONG Size; // // Indicates whether the device can wake itself up while the machine is in // S0. // WDF_POWER_POLICY_S0_IDLE_CAPABILITIES IdleCaps; // // The low power state in which the device will be placed when it is idled // out while the machine is in S0. // DEVICE_POWER_STATE DxState; // // Amount of time the device must be idle before idling out. Timeout is in // milliseconds. // ULONG IdleTimeout; // // Inidcates whether a user can control the idle policy of the device. // By default, a user is allowed to change the policy. // WDF_POWER_POLICY_S0_IDLE_USER_CONTROL UserControlOfIdleSettings; // // If WdfTrue, idling out while the machine is in S0 will be enabled. // // If WdfFalse, idling out will be disabled. // // If WdfUseDefault, the idling out will be enabled. If // UserControlOfIdleSettings is set to IdleAllowUserControl, the user's // settings will override the default. // WDF_TRI_STATE Enabled; // // This field is applicable only when IdleCaps == IdleCannotWakeFromS0 // If WdfTrue,device is powered up on System Wake even if device is idle // If WdfFalse, device is not powered up on system wake if it is idle // If WdfUseDefault, the behavior is same as WdfFalse // WDF_TRI_STATE PowerUpIdleDeviceOnSystemWake; // // This field determines how the IdleTimeout field is used. // // If the value is DriverManagedIdleTimeout, then the idle timeout value // is determined by the IdleTimeout field of this structure. // // If the value is SystemManagedIdleTimeout, then the timeout value is // determined by the power framework (PoFx) on operating systems where // the PoFx is available (i.e. Windows 8 and later). The IdleTimeout field // is ignored on these operating systems. On operating systems where the // PoFx is not available, the behavior is same as DriverManagedIdleTimeout. // // If the value is SystemManagedIdleTimeoutWithHint, then the timeout value // is determined by the power framework (PoFx) on operating systems where // the PoFx is available (i.e. Windows 8 and later). In addition, the value // specified in the IdleTimeout field is provided as a hint to the PoFx in // determining when the device should be allowed to enter a low-power state. // Since it is only a hint, the actual duration after which the PoFx allows // the device to enter a low-power state might be greater than or less than // the IdleTimeout value. On operating systems where the PoFx is not // available, the behavior is same as DriverManagedIdleTimeout. // WDF_POWER_POLICY_IDLE_TIMEOUT_TYPE IdleTimeoutType; // // This field forces the device to avoid idling in the D3cold power state. // WDF will ensure, with help from the bus drivers, that the device will // idle in a D-state that can successfully generate a wake signal, if // necessary. If the client specifies that DxState == PowerDeviceD3, this // setting allows the client to distinguish betwen D3hot and D3cold. If // the client sets DxState == PowerDeviceMaximum, then WDF will pick the // deepest idle state identified by the bus driver. If that deepest state // is D3cold, this field allows the client to override that and choose // D3hot. // // If WdfTrue, device will not use D3cold in S0. // If WdfFalse, device will use D3cold in S0 if the ACPI firmware indicates // that the device can enter that state, if DxState above does not // specify some other D-state and, if the device is armed for // wake, that it can generate its wake signal from D3cold. // If WdfUseDefault, this setting will be derived from the driver's INF, // specifically the presence or absence of the following two lines in // the DDInstall.HW section: // Include=machine.inf // Needs=PciD3ColdSupported // WDF_TRI_STATE ExcludeD3Cold; } WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS, *PWDF_DEVICE_POWER_POLICY_IDLE_SETTINGS; VOID FORCEINLINE WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_INIT( _Out_ PWDF_DEVICE_POWER_POLICY_IDLE_SETTINGS Settings, _In_ WDF_POWER_POLICY_S0_IDLE_CAPABILITIES IdleCaps ) { RtlZeroMemory(Settings, sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS)); Settings->Size = sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS); Settings->IdleTimeout = IdleTimeoutDefaultValue; Settings->UserControlOfIdleSettings = IdleAllowUserControl; Settings->Enabled = WdfUseDefault; Settings->PowerUpIdleDeviceOnSystemWake = WdfUseDefault; Settings->IdleTimeoutType = DriverManagedIdleTimeout; Settings->ExcludeD3Cold = WdfUseDefault; Settings->IdleCaps = IdleCaps; switch (IdleCaps) { case IdleUsbSelectiveSuspend: case IdleCanWakeFromS0: Settings->DxState = PowerDeviceMaximum; break; case IdleCannotWakeFromS0: Settings->DxState = PowerDeviceD3; break; } } typedef struct _WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS { // // Size of this structure in bytes // ULONG Size; // // The low power state in which the device will be placed when it is armed // for wake from Sx. // DEVICE_POWER_STATE DxState; // // Inidcates whether a user can control the idle policy of the device. // By default, a user is allowed to change the policy. // WDF_POWER_POLICY_SX_WAKE_USER_CONTROL UserControlOfWakeSettings; // // If WdfTrue, arming the device for wake while the machine is in Sx is // enabled. // // If WdfFalse, arming the device for wake while the machine is in Sx is // disabled. // // If WdfUseDefault, arming will be enabled. If UserControlOfWakeSettings // is set to WakeAllowUserControl, the user's settings will override the // default. // WDF_TRI_STATE Enabled; // // If set to TRUE, arming the parent device can depend on whether there // is atleast one child device armed for wake. // // If set to FALSE, arming of the parent device will be independent of // whether any of the child devices are armed for wake. // BOOLEAN ArmForWakeIfChildrenAreArmedForWake; // // Indicates that whenever the parent device completes the wake irp // successfully, the status needs to be also propagated to the child // devices. This helps in tracking which devices were responsible for // waking the system. // BOOLEAN IndicateChildWakeOnParentWake; } WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS, *PWDF_DEVICE_POWER_POLICY_WAKE_SETTINGS; VOID FORCEINLINE WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS_INIT( _Out_ PWDF_DEVICE_POWER_POLICY_WAKE_SETTINGS Settings ) { RtlZeroMemory(Settings, sizeof(WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS)); Settings->Size = sizeof(WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS); Settings->Enabled = WdfUseDefault; Settings->DxState = PowerDeviceMaximum; Settings->UserControlOfWakeSettings = WakeAllowUserControl; } typedef struct _WDF_DEVICE_STATE { // // Size of this structure in bytes // ULONG Size; // // If set to WdfTrue, the device will be disabled // WDF_TRI_STATE Disabled; // // If set to WdfTrue, the device will not be displayed in device manager. // Once hidden, the device cannot be unhidden. // WDF_TRI_STATE DontDisplayInUI; // // If set to WdfTrue, the device is reporting itself as failed. If set // in conjuction with ResourcesChanged to WdfTrue, the device will receive // a PnP stop and then a new PnP start device. // WDF_TRI_STATE Failed; // // If set to WdfTrue, the device cannot be subsequently disabled. // WDF_TRI_STATE NotDisableable; // // If set to WdfTrue, the device stack will be torn down. // WDF_TRI_STATE Removed; // // If set to WdfTrue, the device will be sent another PnP start. If the // Failed field is set to WdfTrue as well, a PnP stop will be sent before // the start. // WDF_TRI_STATE ResourcesChanged; } WDF_DEVICE_STATE, *PWDF_DEVICE_STATE; VOID FORCEINLINE WDF_DEVICE_STATE_INIT( _Out_ PWDF_DEVICE_STATE PnpDeviceState ) { RtlZeroMemory(PnpDeviceState, sizeof(WDF_DEVICE_STATE)); PnpDeviceState->Size = sizeof(WDF_DEVICE_STATE); // // Initializes all of the fields to the WdfUseDefault enum value // PnpDeviceState->Disabled = WdfUseDefault; PnpDeviceState->DontDisplayInUI = WdfUseDefault; PnpDeviceState->Failed = WdfUseDefault; PnpDeviceState->NotDisableable = WdfUseDefault; PnpDeviceState->Removed = WdfUseDefault; PnpDeviceState->ResourcesChanged = WdfUseDefault; } typedef struct _WDF_DEVICE_PNP_CAPABILITIES { // // Size of the structure in bytes // ULONG Size; // // NOTE: To mark a PDO as raw, call WdfPdoInitAssignRawDevice // WDF_TRI_STATE LockSupported; WDF_TRI_STATE EjectSupported; WDF_TRI_STATE Removable; WDF_TRI_STATE DockDevice; WDF_TRI_STATE UniqueID; WDF_TRI_STATE SilentInstall; WDF_TRI_STATE SurpriseRemovalOK; WDF_TRI_STATE HardwareDisabled; WDF_TRI_STATE NoDisplayInUI; // // Default values of -1 indicate not to set this value // ULONG Address; ULONG UINumber; } WDF_DEVICE_PNP_CAPABILITIES, *PWDF_DEVICE_PNP_CAPABILITIES; VOID FORCEINLINE WDF_DEVICE_PNP_CAPABILITIES_INIT( _Out_ PWDF_DEVICE_PNP_CAPABILITIES Caps ) { RtlZeroMemory(Caps, sizeof(WDF_DEVICE_PNP_CAPABILITIES)); Caps->Size = sizeof(WDF_DEVICE_PNP_CAPABILITIES); Caps->LockSupported = WdfUseDefault; Caps->EjectSupported = WdfUseDefault; Caps->Removable = WdfUseDefault; Caps->DockDevice = WdfUseDefault; Caps->UniqueID = WdfUseDefault; Caps->SilentInstall = WdfUseDefault; Caps->SurpriseRemovalOK = WdfUseDefault; Caps->HardwareDisabled = WdfUseDefault; Caps->NoDisplayInUI = WdfUseDefault; Caps->Address = (ULONG) -1; Caps->UINumber = (ULONG) -1; } typedef struct _WDF_DEVICE_POWER_CAPABILITIES { // // Size of the structure in bytes // ULONG Size; WDF_TRI_STATE DeviceD1; WDF_TRI_STATE DeviceD2; WDF_TRI_STATE WakeFromD0; WDF_TRI_STATE WakeFromD1; WDF_TRI_STATE WakeFromD2; WDF_TRI_STATE WakeFromD3; // // Default value PowerDeviceMaximum indicates not to set this value // DEVICE_POWER_STATE DeviceState[PowerSystemMaximum]; // // Default value PowerDeviceMaximum, PowerSystemMaximum indicates not to // set this value. // DEVICE_POWER_STATE DeviceWake; SYSTEM_POWER_STATE SystemWake; // // Default values of -1 indicate not to set this value // ULONG D1Latency; ULONG D2Latency; ULONG D3Latency; // // Ideal Dx state for the device to be put into when the machine moves into // Sx and the device is not armed for wake. By default, the default will be // placed into D3. If IdealDxStateForSx is lighter then // DeviceState[Sx], then DeviceState[Sx] will be used as the Dx state. // DEVICE_POWER_STATE IdealDxStateForSx; } WDF_DEVICE_POWER_CAPABILITIES, *PWDF_DEVICE_POWER_CAPABILITIES; VOID FORCEINLINE WDF_DEVICE_POWER_CAPABILITIES_INIT( _Out_ PWDF_DEVICE_POWER_CAPABILITIES Caps ) { ULONG i; RtlZeroMemory(Caps, sizeof(WDF_DEVICE_POWER_CAPABILITIES)); Caps->Size = sizeof(WDF_DEVICE_POWER_CAPABILITIES); Caps->DeviceD1 = WdfUseDefault; Caps->DeviceD2 = WdfUseDefault; Caps->WakeFromD0 = WdfUseDefault; Caps->WakeFromD1 = WdfUseDefault; Caps->WakeFromD2 = WdfUseDefault; Caps->WakeFromD3 = WdfUseDefault; for (i = 0; i < sizeof(Caps->DeviceState)/sizeof(Caps->DeviceState[1]); i++) { Caps->DeviceState[i] = PowerDeviceMaximum; } Caps->DeviceWake = PowerDeviceMaximum; Caps->SystemWake = PowerSystemMaximum; Caps->D1Latency = (ULONG) -1; Caps->D2Latency = (ULONG) -1; Caps->D3Latency = (ULONG) -1; Caps->IdealDxStateForSx = PowerDeviceMaximum; } typedef enum _WDF_REMOVE_LOCK_OPTIONS_FLAGS { WDF_REMOVE_LOCK_OPTION_ACQUIRE_FOR_IO = 0x00000001 } WDF_REMOVE_LOCK_OPTIONS_FLAGS; typedef struct _WDF_REMOVE_LOCK_OPTIONS { // // Size of the structure in bytes // ULONG Size; // // Bit field combination of values from the WDF_REMOVE_LOCK_OPTIONS_FLAGS // enumeration // ULONG Flags; } WDF_REMOVE_LOCK_OPTIONS, *PWDF_REMOVE_LOCK_OPTIONS; // // Default remove lock options initialization macro // VOID FORCEINLINE WDF_REMOVE_LOCK_OPTIONS_INIT( _Out_ PWDF_REMOVE_LOCK_OPTIONS RemoveLockOptions, _In_ ULONG Flags ) { RtlZeroMemory(RemoveLockOptions, sizeof(WDF_REMOVE_LOCK_OPTIONS)); RemoveLockOptions->Size = sizeof(WDF_REMOVE_LOCK_OPTIONS); RemoveLockOptions->Flags = Flags; } typedef _Function_class_(EVT_WDFDEVICE_WDM_IRP_PREPROCESS) _IRQL_requires_same_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS EVT_WDFDEVICE_WDM_IRP_PREPROCESS( _In_ WDFDEVICE Device, _Inout_ PIRP Irp ); typedef EVT_WDFDEVICE_WDM_IRP_PREPROCESS *PFN_WDFDEVICE_WDM_IRP_PREPROCESS; typedef _Function_class_(EVT_WDFDEVICE_WDM_IRP_DISPATCH) _IRQL_requires_same_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS EVT_WDFDEVICE_WDM_IRP_DISPATCH( _In_ WDFDEVICE Device, _In_ UCHAR MajorFunction, _In_ UCHAR MinorFunction, _In_ ULONG Code, _In_ WDFCONTEXT DriverContext, _Inout_ PIRP Irp, _In_ WDFCONTEXT DispatchContext ); typedef EVT_WDFDEVICE_WDM_IRP_DISPATCH *PFN_WDFDEVICE_WDM_IRP_DISPATCH; // // This is called to pre-process a request using METHOD_NEITHER // typedef _Function_class_(EVT_WDF_IO_IN_CALLER_CONTEXT) _IRQL_requires_same_ _IRQL_requires_max_(DISPATCH_LEVEL) VOID EVT_WDF_IO_IN_CALLER_CONTEXT( _In_ WDFDEVICE Device, _In_ WDFREQUEST Request ); typedef EVT_WDF_IO_IN_CALLER_CONTEXT *PFN_WDF_IO_IN_CALLER_CONTEXT; typedef _Function_class_(EVT_WDFDEVICE_WDM_POST_PO_FX_REGISTER_DEVICE) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EVT_WDFDEVICE_WDM_POST_PO_FX_REGISTER_DEVICE( _In_ WDFDEVICE Device, _In_ POHANDLE PoHandle ); typedef EVT_WDFDEVICE_WDM_POST_PO_FX_REGISTER_DEVICE *PFN_WDFDEVICE_WDM_POST_PO_FX_REGISTER_DEVICE; typedef _Function_class_(EVT_WDFDEVICE_WDM_PRE_PO_FX_UNREGISTER_DEVICE) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID EVT_WDFDEVICE_WDM_PRE_PO_FX_UNREGISTER_DEVICE( _In_ WDFDEVICE Device, _In_ POHANDLE PoHandle ); typedef EVT_WDFDEVICE_WDM_PRE_PO_FX_UNREGISTER_DEVICE *PFN_WDFDEVICE_WDM_PRE_PO_FX_UNREGISTER_DEVICE; typedef struct _WDF_POWER_FRAMEWORK_SETTINGS { // // Size of the structure, in bytes. // ULONG Size; // // Client driver's callback function that is invoked after KMDF has // registered with the power framework. This field can be NULL if the // client driver does not wish to specify this callback. // PFN_WDFDEVICE_WDM_POST_PO_FX_REGISTER_DEVICE EvtDeviceWdmPostPoFxRegisterDevice; // // Client driver's callback function that is invoked before KMDF // unregisters with the power framework. This field can be NULL if the // client driver does not wish to specify this callback. // PFN_WDFDEVICE_WDM_PRE_PO_FX_UNREGISTER_DEVICE EvtDeviceWdmPrePoFxUnregisterDevice; // // Pointer to a PO_FX_COMPONENT structure that describes the only component // in the single-component device. This field can be NULL if the client // driver wants KMDF to use the default specification for this component // (i.e. support for F0 only). // PPO_FX_COMPONENT Component; // // Client driver's PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK callback // function. This field can be NULL if the client driver does not wish to // specify this callback. // PPO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK ComponentActiveConditionCallback; // // Client driver's PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK callback // function. This field can be NULL if the client driver does not wish to // specify this callback. // PPO_FX_COMPONENT_IDLE_CONDITION_CALLBACK ComponentIdleConditionCallback; // // Client driver's PO_FX_COMPONENT_IDLE_STATE_CALLBACK callback function. // This field can be NULL if the client driver does not wish to specify // this callback. // PPO_FX_COMPONENT_IDLE_STATE_CALLBACK ComponentIdleStateCallback; // // Client driver's PO_FX_POWER_CONTROL_CALLBACK callback function. This // field can be NULL if the client driver does not wish to specify this // callback. // PPO_FX_POWER_CONTROL_CALLBACK PowerControlCallback; // // Context value that is passed in to the ComponentIdleStateCallback and // PowerControlCallback callback functions. // PVOID PoFxDeviceContext; } WDF_POWER_FRAMEWORK_SETTINGS, *PWDF_POWER_FRAMEWORK_SETTINGS; VOID FORCEINLINE WDF_POWER_FRAMEWORK_SETTINGS_INIT( _Out_ PWDF_POWER_FRAMEWORK_SETTINGS PowerFrameworkSettings ) { RtlZeroMemory(PowerFrameworkSettings, sizeof(WDF_POWER_FRAMEWORK_SETTINGS)); PowerFrameworkSettings->Size = sizeof(WDF_POWER_FRAMEWORK_SETTINGS); } typedef struct _WDF_IO_TYPE_CONFIG { // // Size of this structure in bytes // ULONG Size; // // // Identifies the method that the driver will use to access data buffers // that it receives for read and write requests. // // // Identifies the method that the driver will "prefer" to use to access data // buffers that it receives for read and write requests. Note that UMDF // driver provides just a preference, and not a guarantee.Therefore, // even if a driver specified direct access method, UMDF might use the // buffered access method for one or more of the device's requests to // improve performance. For example, UMDF uses buffered access for small // buffers, if it can copy the data to the driver's buffer faster than it // can map the buffers for direct access. // WDF_DEVICE_IO_TYPE ReadWriteIoType; // // // Identifies the method that the driver will "prefer" to use to access data // buffers that it receives for IOCTL requests. Note that UMDF // driver provides just a preference, and not a guarantee. Therefore, // even if a driver specified direct access method, UMDF might use the // buffered access method for one or more of the device's requests to // improve performance. For example, UMDF uses buffered access for small // buffers, if it can copy the data to the driver's buffer faster than it // can map the buffers for direct access. // WDF_DEVICE_IO_TYPE DeviceControlIoType; // // // Optional, Provides the smallest buffer size (in bytes) for which // UMDF will use direct access for the buffers. For example, set // DirectTransferThreshold to "12288" to indicate that UMDF should use buffered // access for all buffers that are smaller than 12 kilobytes, and direct // access for buffers equal to or greater than that. Typically, you // do not need to provide this value because UMDF uses a value that provides // the best performance. Note that there are other requirements that must be // met in order to get direct access of buffers. See Docs for details. // ULONG DirectTransferThreshold; } WDF_IO_TYPE_CONFIG, *PWDF_IO_TYPE_CONFIG; VOID FORCEINLINE WDF_IO_TYPE_CONFIG_INIT( _Out_ PWDF_IO_TYPE_CONFIG IoTypeConfig ) { RtlZeroMemory(IoTypeConfig, sizeof(WDF_IO_TYPE_CONFIG)); IoTypeConfig->Size = sizeof(WDF_IO_TYPE_CONFIG); IoTypeConfig->ReadWriteIoType = WdfDeviceIoBuffered; IoTypeConfig->DeviceControlIoType = WdfDeviceIoBuffered; } typedef struct _WDF_DEVICE_INTERFACE_PROPERTY_DATA { _In_ ULONG Size; // // A pointer to a GUID that identifies the device interface class. // _In_ const GUID * InterfaceClassGUID; // // A pointer to a UNICODE_STRING structure that describes a reference // string for the device interface. This parameter is optional and can // be NULL. _In_opt_ PCUNICODE_STRING ReferenceString; // // A pointer to a DEVPROPKEY structure that specifies the device // property key. // _In_ const DEVPROPKEY * PropertyKey; // // A locale identifier. Set this parameter either to a language-specific // LCID value or to LOCALE_NEUTRAL. The LOCALE_NEUTRAL LCID specifies // that the property is language-neutral (that is, not specific to any // language). Do not set this parameter to LOCALE_SYSTEM_DEFAULT or // LOCALE_USER_DEFAULT. For more information about language-specific // LCID values, see LCID Structure. // _In_ LCID Lcid; // // Set this parameter to PLUGPLAY_PROPERTY_PERSISTENT if the property // value set by this routine should persist across computer restarts. // Otherwise, set Flags to zero. Ignored for Query DDIs. // _In_ ULONG Flags; } WDF_DEVICE_INTERFACE_PROPERTY_DATA, *PWDF_DEVICE_INTERFACE_PROPERTY_DATA; FORCEINLINE VOID WDF_DEVICE_INTERFACE_PROPERTY_DATA_INIT ( _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData, _In_ const GUID* InterfaceClassGUID, _In_ const DEVPROPKEY* PropertyKey ) { RtlZeroMemory(PropertyData, sizeof(* PropertyData)); PropertyData->Size = sizeof(*PropertyData); PropertyData->InterfaceClassGUID = InterfaceClassGUID; PropertyData->PropertyKey = PropertyKey; } typedef struct _WDF_DEVICE_PROPERTY_DATA { // // Size of this structure // _In_ ULONG Size; // // A pointer to a DEVPROPKEY structure that specifies the device // property key. // _In_ const DEVPROPKEY * PropertyKey; // // A locale identifier. Set this parameter either to a language-specific // LCID value or to LOCALE_NEUTRAL. The LOCALE_NEUTRAL LCID specifies // that the property is language-neutral (that is, not specific to any // language). Do not set this parameter to LOCALE_SYSTEM_DEFAULT or // LOCALE_USER_DEFAULT. For more information about language-specific // LCID values, see LCID Structure. // _In_ LCID Lcid; // // Set this parameter to PLUGPLAY_PROPERTY_PERSISTENT if the property // value set by this routine should persist across computer restarts. // Otherwise, set Flags to zero. Ignored for Query DDIs. // _In_ ULONG Flags; } WDF_DEVICE_PROPERTY_DATA, *PWDF_DEVICE_PROPERTY_DATA; FORCEINLINE VOID WDF_DEVICE_PROPERTY_DATA_INIT ( _Out_ PWDF_DEVICE_PROPERTY_DATA PropertyData, _In_ const DEVPROPKEY* PropertyKey ) { RtlZeroMemory(PropertyData, sizeof(* PropertyData)); PropertyData->Size = sizeof(*PropertyData); PropertyData->PropertyKey = PropertyKey; } // // VOID // WdfDeviceStopIdle( // _In_ WDFDEVICE Device, // _In_ BOOLEAN WaitForD0 // ); // // VOID // WdfDeviceStopIdleWithTag( // _In_ WDFDEVICE Device, // _In_ BOOLEAN WaitForD0, // _In_ PVOID Tag // ); // // VOID // WdfDeviceResumeIdle( // _In_ WDFDEVICE Device // ); // // VOID // WdfDeviceResumeIdleWithTag( // _In_ WDFDEVICE Device // _In_ PVOID Tag // ); // #define WdfDeviceStopIdle(Device, WaitForD0) \ WdfDeviceStopIdleWithTag(Device, WaitForD0, NULL) #define WdfDeviceStopIdleWithTag(Device, WaitForD0, Tag) \ WdfDeviceStopIdleActual(Device, WaitForD0, Tag, __LINE__, __FILE__) #define WdfDeviceResumeIdle(Device) \ WdfDeviceResumeIdleWithTag(Device, NULL) #define WdfDeviceResumeIdleWithTag(Device, Tag) \ WdfDeviceResumeIdleActual(Device, Tag, __LINE__, __FILE__) // // WDF Function: WdfDeviceGetDeviceState // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEGETDEVICESTATE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _Out_ PWDF_DEVICE_STATE DeviceState ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceGetDeviceState( _In_ WDFDEVICE Device, _Out_ PWDF_DEVICE_STATE DeviceState ) { ((PFN_WDFDEVICEGETDEVICESTATE) WdfFunctions[WdfDeviceGetDeviceStateTableIndex])(WdfDriverGlobals, Device, DeviceState); } // // WDF Function: WdfDeviceSetDeviceState // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICESETDEVICESTATE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_STATE DeviceState ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceSetDeviceState( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_STATE DeviceState ) { ((PFN_WDFDEVICESETDEVICESTATE) WdfFunctions[WdfDeviceSetDeviceStateTableIndex])(WdfDriverGlobals, Device, DeviceState); } // // WDF Function: WdfDeviceWdmDispatchIrp // typedef _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEWDMDISPATCHIRP)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PIRP Irp, _In_ WDFCONTEXT DispatchContext ); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS FORCEINLINE WdfDeviceWdmDispatchIrp( _In_ WDFDEVICE Device, _In_ PIRP Irp, _In_ WDFCONTEXT DispatchContext ) { return ((PFN_WDFDEVICEWDMDISPATCHIRP) WdfFunctions[WdfDeviceWdmDispatchIrpTableIndex])(WdfDriverGlobals, Device, Irp, DispatchContext); } // // WDF Function: WdfDeviceWdmDispatchIrpToIoQueue // typedef _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEWDMDISPATCHIRPTOIOQUEUE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PIRP Irp, _In_ WDFQUEUE Queue, _In_ ULONG Flags ); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS FORCEINLINE WdfDeviceWdmDispatchIrpToIoQueue( _In_ WDFDEVICE Device, _In_ PIRP Irp, _In_ WDFQUEUE Queue, _In_ ULONG Flags ) { return ((PFN_WDFDEVICEWDMDISPATCHIRPTOIOQUEUE) WdfFunctions[WdfDeviceWdmDispatchIrpToIoQueueTableIndex])(WdfDriverGlobals, Device, Irp, Queue, Flags); } // // WDF Function: WdfDeviceGetDriver // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDRIVER (*PFN_WDFDEVICEGETDRIVER)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device ); _IRQL_requires_max_(DISPATCH_LEVEL) WDFDRIVER FORCEINLINE WdfDeviceGetDriver( _In_ WDFDEVICE Device ) { return ((PFN_WDFDEVICEGETDRIVER) WdfFunctions[WdfDeviceGetDriverTableIndex])(WdfDriverGlobals, Device); } // // WDF Function: WdfDeviceGetIoTarget // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFIOTARGET (*PFN_WDFDEVICEGETIOTARGET)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device ); _IRQL_requires_max_(DISPATCH_LEVEL) WDFIOTARGET FORCEINLINE WdfDeviceGetIoTarget( _In_ WDFDEVICE Device ) { return ((PFN_WDFDEVICEGETIOTARGET) WdfFunctions[WdfDeviceGetIoTargetTableIndex])(WdfDriverGlobals, Device); } // // WDF Function: WdfDeviceAssignS0IdleSettings // typedef _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEASSIGNS0IDLESETTINGS)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_POWER_POLICY_IDLE_SETTINGS Settings ); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS FORCEINLINE WdfDeviceAssignS0IdleSettings( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_POWER_POLICY_IDLE_SETTINGS Settings ) { return ((PFN_WDFDEVICEASSIGNS0IDLESETTINGS) WdfFunctions[WdfDeviceAssignS0IdleSettingsTableIndex])(WdfDriverGlobals, Device, Settings); } // // WDF Function: WdfDeviceAssignSxWakeSettings // typedef _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEASSIGNSXWAKESETTINGS)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_POWER_POLICY_WAKE_SETTINGS Settings ); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS FORCEINLINE WdfDeviceAssignSxWakeSettings( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_POWER_POLICY_WAKE_SETTINGS Settings ) { return ((PFN_WDFDEVICEASSIGNSXWAKESETTINGS) WdfFunctions[WdfDeviceAssignSxWakeSettingsTableIndex])(WdfDriverGlobals, Device, Settings); } // // WDF Function: WdfDeviceOpenRegistryKey // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEOPENREGISTRYKEY)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ ULONG DeviceInstanceKeyType, _In_ ACCESS_MASK DesiredAccess, _In_opt_ PWDF_OBJECT_ATTRIBUTES KeyAttributes, _Out_ WDFKEY* Key ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceOpenRegistryKey( _In_ WDFDEVICE Device, _In_ ULONG DeviceInstanceKeyType, _In_ ACCESS_MASK DesiredAccess, _In_opt_ PWDF_OBJECT_ATTRIBUTES KeyAttributes, _Out_ WDFKEY* Key ) { return ((PFN_WDFDEVICEOPENREGISTRYKEY) WdfFunctions[WdfDeviceOpenRegistryKeyTableIndex])(WdfDriverGlobals, Device, DeviceInstanceKeyType, DesiredAccess, KeyAttributes, Key); } // // WDF Function: WdfDeviceOpenDevicemapKey // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEOPENDEVICEMAPKEY)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PCUNICODE_STRING KeyName, _In_ ACCESS_MASK DesiredAccess, _In_opt_ PWDF_OBJECT_ATTRIBUTES KeyAttributes, _Out_ WDFKEY* Key ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceOpenDevicemapKey( _In_ WDFDEVICE Device, _In_ PCUNICODE_STRING KeyName, _In_ ACCESS_MASK DesiredAccess, _In_opt_ PWDF_OBJECT_ATTRIBUTES KeyAttributes, _Out_ WDFKEY* Key ) { return ((PFN_WDFDEVICEOPENDEVICEMAPKEY) WdfFunctions[WdfDeviceOpenDevicemapKeyTableIndex])(WdfDriverGlobals, Device, KeyName, DesiredAccess, KeyAttributes, Key); } // // WDF Function: WdfDeviceInitSetPnpPowerEventCallbacks // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEINITSETPNPPOWEREVENTCALLBACKS)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_PNPPOWER_EVENT_CALLBACKS PnpPowerEventCallbacks ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceInitSetPnpPowerEventCallbacks( _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_PNPPOWER_EVENT_CALLBACKS PnpPowerEventCallbacks ) { ((PFN_WDFDEVICEINITSETPNPPOWEREVENTCALLBACKS) WdfFunctions[WdfDeviceInitSetPnpPowerEventCallbacksTableIndex])(WdfDriverGlobals, DeviceInit, PnpPowerEventCallbacks); } // // WDF Function: WdfDeviceInitSetPowerPolicyEventCallbacks // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEINITSETPOWERPOLICYEVENTCALLBACKS)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_POWER_POLICY_EVENT_CALLBACKS PowerPolicyEventCallbacks ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceInitSetPowerPolicyEventCallbacks( _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_POWER_POLICY_EVENT_CALLBACKS PowerPolicyEventCallbacks ) { ((PFN_WDFDEVICEINITSETPOWERPOLICYEVENTCALLBACKS) WdfFunctions[WdfDeviceInitSetPowerPolicyEventCallbacksTableIndex])(WdfDriverGlobals, DeviceInit, PowerPolicyEventCallbacks); } // // WDF Function: WdfDeviceInitSetPowerPolicyOwnership // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEINITSETPOWERPOLICYOWNERSHIP)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ PWDFDEVICE_INIT DeviceInit, _In_ BOOLEAN IsPowerPolicyOwner ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceInitSetPowerPolicyOwnership( _In_ PWDFDEVICE_INIT DeviceInit, _In_ BOOLEAN IsPowerPolicyOwner ) { ((PFN_WDFDEVICEINITSETPOWERPOLICYOWNERSHIP) WdfFunctions[WdfDeviceInitSetPowerPolicyOwnershipTableIndex])(WdfDriverGlobals, DeviceInit, IsPowerPolicyOwner); } // // WDF Function: WdfDeviceInitSetIoType // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEINITSETIOTYPE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ PWDFDEVICE_INIT DeviceInit, _In_ WDF_DEVICE_IO_TYPE IoType ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceInitSetIoType( _In_ PWDFDEVICE_INIT DeviceInit, _In_ WDF_DEVICE_IO_TYPE IoType ) { ((PFN_WDFDEVICEINITSETIOTYPE) WdfFunctions[WdfDeviceInitSetIoTypeTableIndex])(WdfDriverGlobals, DeviceInit, IoType); } // // WDF Function: WdfDeviceInitSetFileObjectConfig // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEINITSETFILEOBJECTCONFIG)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_FILEOBJECT_CONFIG FileObjectConfig, _In_opt_ PWDF_OBJECT_ATTRIBUTES FileObjectAttributes ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceInitSetFileObjectConfig( _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_FILEOBJECT_CONFIG FileObjectConfig, _In_opt_ PWDF_OBJECT_ATTRIBUTES FileObjectAttributes ) { ((PFN_WDFDEVICEINITSETFILEOBJECTCONFIG) WdfFunctions[WdfDeviceInitSetFileObjectConfigTableIndex])(WdfDriverGlobals, DeviceInit, FileObjectConfig, FileObjectAttributes); } // // WDF Function: WdfDeviceInitSetRequestAttributes // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEINITSETREQUESTATTRIBUTES)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_OBJECT_ATTRIBUTES RequestAttributes ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceInitSetRequestAttributes( _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_OBJECT_ATTRIBUTES RequestAttributes ) { ((PFN_WDFDEVICEINITSETREQUESTATTRIBUTES) WdfFunctions[WdfDeviceInitSetRequestAttributesTableIndex])(WdfDriverGlobals, DeviceInit, RequestAttributes); } // // WDF Function: WdfDeviceCreate // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICECREATE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _Inout_ PWDFDEVICE_INIT* DeviceInit, _In_opt_ PWDF_OBJECT_ATTRIBUTES DeviceAttributes, _Out_ WDFDEVICE* Device ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceCreate( _Inout_ PWDFDEVICE_INIT* DeviceInit, _In_opt_ PWDF_OBJECT_ATTRIBUTES DeviceAttributes, _Out_ WDFDEVICE* Device ) { return ((PFN_WDFDEVICECREATE) WdfFunctions[WdfDeviceCreateTableIndex])(WdfDriverGlobals, DeviceInit, DeviceAttributes, Device); } // // WDF Function: WdfDeviceSetStaticStopRemove // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICESETSTATICSTOPREMOVE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ BOOLEAN Stoppable ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceSetStaticStopRemove( _In_ WDFDEVICE Device, _In_ BOOLEAN Stoppable ) { ((PFN_WDFDEVICESETSTATICSTOPREMOVE) WdfFunctions[WdfDeviceSetStaticStopRemoveTableIndex])(WdfDriverGlobals, Device, Stoppable); } // // WDF Function: WdfDeviceCreateDeviceInterface // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICECREATEDEVICEINTERFACE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ CONST GUID* InterfaceClassGUID, _In_opt_ PCUNICODE_STRING ReferenceString ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceCreateDeviceInterface( _In_ WDFDEVICE Device, _In_ CONST GUID* InterfaceClassGUID, _In_opt_ PCUNICODE_STRING ReferenceString ) { return ((PFN_WDFDEVICECREATEDEVICEINTERFACE) WdfFunctions[WdfDeviceCreateDeviceInterfaceTableIndex])(WdfDriverGlobals, Device, InterfaceClassGUID, ReferenceString); } // // WDF Function: WdfDeviceSetDeviceInterfaceState // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID (*PFN_WDFDEVICESETDEVICEINTERFACESTATE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ CONST GUID* InterfaceClassGUID, _In_opt_ PCUNICODE_STRING ReferenceString, _In_ BOOLEAN IsInterfaceEnabled ); _IRQL_requires_max_(PASSIVE_LEVEL) VOID FORCEINLINE WdfDeviceSetDeviceInterfaceState( _In_ WDFDEVICE Device, _In_ CONST GUID* InterfaceClassGUID, _In_opt_ PCUNICODE_STRING ReferenceString, _In_ BOOLEAN IsInterfaceEnabled ) { ((PFN_WDFDEVICESETDEVICEINTERFACESTATE) WdfFunctions[WdfDeviceSetDeviceInterfaceStateTableIndex])(WdfDriverGlobals, Device, InterfaceClassGUID, ReferenceString, IsInterfaceEnabled); } // // WDF Function: WdfDeviceRetrieveDeviceInterfaceString // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICERETRIEVEDEVICEINTERFACESTRING)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ CONST GUID* InterfaceClassGUID, _In_opt_ PCUNICODE_STRING ReferenceString, _In_ WDFSTRING String ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceRetrieveDeviceInterfaceString( _In_ WDFDEVICE Device, _In_ CONST GUID* InterfaceClassGUID, _In_opt_ PCUNICODE_STRING ReferenceString, _In_ WDFSTRING String ) { return ((PFN_WDFDEVICERETRIEVEDEVICEINTERFACESTRING) WdfFunctions[WdfDeviceRetrieveDeviceInterfaceStringTableIndex])(WdfDriverGlobals, Device, InterfaceClassGUID, ReferenceString, String); } // // WDF Function: WdfDeviceCreateSymbolicLink // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICECREATESYMBOLICLINK)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PCUNICODE_STRING SymbolicLinkName ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceCreateSymbolicLink( _In_ WDFDEVICE Device, _In_ PCUNICODE_STRING SymbolicLinkName ) { return ((PFN_WDFDEVICECREATESYMBOLICLINK) WdfFunctions[WdfDeviceCreateSymbolicLinkTableIndex])(WdfDriverGlobals, Device, SymbolicLinkName); } // // WDF Function: WdfDeviceQueryProperty // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEQUERYPROPERTY)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ ULONG BufferLength, _Out_writes_bytes_all_(BufferLength) PVOID PropertyBuffer, _Out_ PULONG ResultLength ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceQueryProperty( _In_ WDFDEVICE Device, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ ULONG BufferLength, _Out_writes_bytes_all_(BufferLength) PVOID PropertyBuffer, _Out_ PULONG ResultLength ) { return ((PFN_WDFDEVICEQUERYPROPERTY) WdfFunctions[WdfDeviceQueryPropertyTableIndex])(WdfDriverGlobals, Device, DeviceProperty, BufferLength, PropertyBuffer, ResultLength); } // // WDF Function: WdfDeviceAllocAndQueryProperty // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEALLOCANDQUERYPROPERTY)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ _Strict_type_match_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY* PropertyMemory ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceAllocAndQueryProperty( _In_ WDFDEVICE Device, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ _Strict_type_match_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY* PropertyMemory ) { return ((PFN_WDFDEVICEALLOCANDQUERYPROPERTY) WdfFunctions[WdfDeviceAllocAndQueryPropertyTableIndex])(WdfDriverGlobals, Device, DeviceProperty, PoolType, PropertyMemoryAttributes, PropertyMemory); } // // WDF Function: WdfDeviceSetPnpCapabilities // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICESETPNPCAPABILITIES)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_PNP_CAPABILITIES PnpCapabilities ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceSetPnpCapabilities( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_PNP_CAPABILITIES PnpCapabilities ) { ((PFN_WDFDEVICESETPNPCAPABILITIES) WdfFunctions[WdfDeviceSetPnpCapabilitiesTableIndex])(WdfDriverGlobals, Device, PnpCapabilities); } // // WDF Function: WdfDeviceSetPowerCapabilities // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICESETPOWERCAPABILITIES)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_POWER_CAPABILITIES PowerCapabilities ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceSetPowerCapabilities( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_POWER_CAPABILITIES PowerCapabilities ) { ((PFN_WDFDEVICESETPOWERCAPABILITIES) WdfFunctions[WdfDeviceSetPowerCapabilitiesTableIndex])(WdfDriverGlobals, Device, PowerCapabilities); } // // WDF Function: WdfDeviceSetFailed // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICESETFAILED)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ WDF_DEVICE_FAILED_ACTION FailedAction ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceSetFailed( _In_ WDFDEVICE Device, _In_ WDF_DEVICE_FAILED_ACTION FailedAction ) { ((PFN_WDFDEVICESETFAILED) WdfFunctions[WdfDeviceSetFailedTableIndex])(WdfDriverGlobals, Device, FailedAction); } // // WDF Function: WdfDeviceStopIdleNoTrack // typedef _Must_inspect_result_ _When_(WaitForD0 == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(WaitForD0 != 0, _IRQL_requires_max_(PASSIVE_LEVEL)) WDFAPI NTSTATUS (*PFN_WDFDEVICESTOPIDLENOTRACK)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ BOOLEAN WaitForD0 ); _Must_inspect_result_ _When_(WaitForD0 == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(WaitForD0 != 0, _IRQL_requires_max_(PASSIVE_LEVEL)) NTSTATUS FORCEINLINE WdfDeviceStopIdleNoTrack( _In_ WDFDEVICE Device, _In_ BOOLEAN WaitForD0 ) { return ((PFN_WDFDEVICESTOPIDLENOTRACK) WdfFunctions[WdfDeviceStopIdleNoTrackTableIndex])(WdfDriverGlobals, Device, WaitForD0); } // // WDF Function: WdfDeviceResumeIdleNoTrack // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICERESUMEIDLENOTRACK)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceResumeIdleNoTrack( _In_ WDFDEVICE Device ) { ((PFN_WDFDEVICERESUMEIDLENOTRACK) WdfFunctions[WdfDeviceResumeIdleNoTrackTableIndex])(WdfDriverGlobals, Device); } // // WDF Function: WdfDeviceStopIdleActual // typedef _Must_inspect_result_ _When_(WaitForD0 == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(WaitForD0 != 0, _IRQL_requires_max_(PASSIVE_LEVEL)) WDFAPI NTSTATUS (*PFN_WDFDEVICESTOPIDLEACTUAL)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ BOOLEAN WaitForD0, _In_opt_ PVOID Tag, _In_ LONG Line, _In_z_ PCCH File ); _Must_inspect_result_ _When_(WaitForD0 == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(WaitForD0 != 0, _IRQL_requires_max_(PASSIVE_LEVEL)) NTSTATUS FORCEINLINE WdfDeviceStopIdleActual( _In_ WDFDEVICE Device, _In_ BOOLEAN WaitForD0, _In_opt_ PVOID Tag, _In_ LONG Line, _In_z_ PCCH File ) { return ((PFN_WDFDEVICESTOPIDLEACTUAL) WdfFunctions[WdfDeviceStopIdleActualTableIndex])(WdfDriverGlobals, Device, WaitForD0, Tag, Line, File); } // // WDF Function: WdfDeviceResumeIdleActual // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICERESUMEIDLEACTUAL)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_opt_ PVOID Tag, _In_ LONG Line, _In_z_ PCCH File ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceResumeIdleActual( _In_ WDFDEVICE Device, _In_opt_ PVOID Tag, _In_ LONG Line, _In_z_ PCCH File ) { ((PFN_WDFDEVICERESUMEIDLEACTUAL) WdfFunctions[WdfDeviceResumeIdleActualTableIndex])(WdfDriverGlobals, Device, Tag, Line, File); } // // WDF Function: WdfDeviceGetFileObject // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFFILEOBJECT (*PFN_WDFDEVICEGETFILEOBJECT)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PFILE_OBJECT FileObject ); // // WDF Function: WdfDeviceGetDefaultQueue // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFQUEUE (*PFN_WDFDEVICEGETDEFAULTQUEUE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device ); _IRQL_requires_max_(DISPATCH_LEVEL) WDFQUEUE FORCEINLINE WdfDeviceGetDefaultQueue( _In_ WDFDEVICE Device ) { return ((PFN_WDFDEVICEGETDEFAULTQUEUE) WdfFunctions[WdfDeviceGetDefaultQueueTableIndex])(WdfDriverGlobals, Device); } // // WDF Function: WdfDeviceConfigureRequestDispatching // typedef _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICECONFIGUREREQUESTDISPATCHING)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ WDFQUEUE Queue, _In_ _Strict_type_match_ WDF_REQUEST_TYPE RequestType ); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS FORCEINLINE WdfDeviceConfigureRequestDispatching( _In_ WDFDEVICE Device, _In_ WDFQUEUE Queue, _In_ _Strict_type_match_ WDF_REQUEST_TYPE RequestType ) { return ((PFN_WDFDEVICECONFIGUREREQUESTDISPATCHING) WdfFunctions[WdfDeviceConfigureRequestDispatchingTableIndex])(WdfDriverGlobals, Device, Queue, RequestType); } // // WDF Function: WdfDeviceConfigureWdmIrpDispatchCallback // typedef _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICECONFIGUREWDMIRPDISPATCHCALLBACK)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_opt_ WDFDRIVER Driver, _In_ UCHAR MajorFunction, _In_ PFN_WDFDEVICE_WDM_IRP_DISPATCH EvtDeviceWdmIrpDisptach, _In_opt_ WDFCONTEXT DriverContext ); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS FORCEINLINE WdfDeviceConfigureWdmIrpDispatchCallback( _In_ WDFDEVICE Device, _In_opt_ WDFDRIVER Driver, _In_ UCHAR MajorFunction, _In_ PFN_WDFDEVICE_WDM_IRP_DISPATCH EvtDeviceWdmIrpDisptach, _In_opt_ WDFCONTEXT DriverContext ) { return ((PFN_WDFDEVICECONFIGUREWDMIRPDISPATCHCALLBACK) WdfFunctions[WdfDeviceConfigureWdmIrpDispatchCallbackTableIndex])(WdfDriverGlobals, Device, Driver, MajorFunction, EvtDeviceWdmIrpDisptach, DriverContext); } // // WDF Function: WdfDeviceGetSystemPowerAction // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI POWER_ACTION (*PFN_WDFDEVICEGETSYSTEMPOWERACTION)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device ); _IRQL_requires_max_(DISPATCH_LEVEL) POWER_ACTION FORCEINLINE WdfDeviceGetSystemPowerAction( _In_ WDFDEVICE Device ) { return ((PFN_WDFDEVICEGETSYSTEMPOWERACTION) WdfFunctions[WdfDeviceGetSystemPowerActionTableIndex])(WdfDriverGlobals, Device); } // // WDF Function: WdfDeviceInitSetReleaseHardwareOrderOnFailure // typedef _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEINITSETRELEASEHARDWAREORDERONFAILURE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ PWDFDEVICE_INIT DeviceInit, _In_ WDF_RELEASE_HARDWARE_ORDER_ON_FAILURE ReleaseHardwareOrderOnFailure ); _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE WdfDeviceInitSetReleaseHardwareOrderOnFailure( _In_ PWDFDEVICE_INIT DeviceInit, _In_ WDF_RELEASE_HARDWARE_ORDER_ON_FAILURE ReleaseHardwareOrderOnFailure ) { ((PFN_WDFDEVICEINITSETRELEASEHARDWAREORDERONFAILURE) WdfFunctions[WdfDeviceInitSetReleaseHardwareOrderOnFailureTableIndex])(WdfDriverGlobals, DeviceInit, ReleaseHardwareOrderOnFailure); } // // WDF Function: WdfDeviceInitSetIoTypeEx // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEINITSETIOTYPEEX)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_IO_TYPE_CONFIG IoTypeConfig ); _IRQL_requires_max_(PASSIVE_LEVEL) VOID FORCEINLINE WdfDeviceInitSetIoTypeEx( _In_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_IO_TYPE_CONFIG IoTypeConfig ) { ((PFN_WDFDEVICEINITSETIOTYPEEX) WdfFunctions[WdfDeviceInitSetIoTypeExTableIndex])(WdfDriverGlobals, DeviceInit, IoTypeConfig); } // // WDF Function: WdfDevicePostEvent // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEPOSTEVENT)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ REFGUID EventGuid, _In_ WDF_EVENT_TYPE WdfEventType, _In_reads_bytes_(DataSizeCb) BYTE* Data, _In_ ULONG DataSizeCb ); _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDevicePostEvent( _In_ WDFDEVICE Device, _In_ REFGUID EventGuid, _In_ WDF_EVENT_TYPE WdfEventType, _In_reads_bytes_(DataSizeCb) BYTE* Data, _In_ ULONG DataSizeCb ) { return ((PFN_WDFDEVICEPOSTEVENT) WdfFunctions[WdfDevicePostEventTableIndex])(WdfDriverGlobals, Device, EventGuid, WdfEventType, Data, DataSizeCb); } // // WDF Function: WdfDeviceMapIoSpace // typedef _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEMAPIOSPACE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PHYSICAL_ADDRESS PhysicalAddress, _In_ SIZE_T NumberOfBytes, _In_ MEMORY_CACHING_TYPE CacheType, _Out_ PVOID* PseudoBaseAddress ); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceMapIoSpace( _In_ WDFDEVICE Device, _In_ PHYSICAL_ADDRESS PhysicalAddress, _In_ SIZE_T NumberOfBytes, _In_ MEMORY_CACHING_TYPE CacheType, _Out_ PVOID* PseudoBaseAddress ) { return ((PFN_WDFDEVICEMAPIOSPACE) WdfFunctions[WdfDeviceMapIoSpaceTableIndex])(WdfDriverGlobals, Device, PhysicalAddress, NumberOfBytes, CacheType, PseudoBaseAddress); } // // WDF Function: WdfDeviceUnmapIoSpace // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEUNMAPIOSPACE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PVOID PseudoBaseAddress, _In_ SIZE_T NumberOfBytes ); _IRQL_requires_max_(PASSIVE_LEVEL) VOID FORCEINLINE WdfDeviceUnmapIoSpace( _In_ WDFDEVICE Device, _In_ PVOID PseudoBaseAddress, _In_ SIZE_T NumberOfBytes ) { ((PFN_WDFDEVICEUNMAPIOSPACE) WdfFunctions[WdfDeviceUnmapIoSpaceTableIndex])(WdfDriverGlobals, Device, PseudoBaseAddress, NumberOfBytes); } // // WDF Function: WdfDeviceGetHardwareRegisterMappedAddress // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI PVOID (*PFN_WDFDEVICEGETHARDWAREREGISTERMAPPEDADDRESS)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PVOID PseudoBaseAddress ); _IRQL_requires_max_(PASSIVE_LEVEL) PVOID FORCEINLINE WdfDeviceGetHardwareRegisterMappedAddress( _In_ WDFDEVICE Device, _In_ PVOID PseudoBaseAddress ) { return ((PFN_WDFDEVICEGETHARDWAREREGISTERMAPPEDADDRESS) WdfFunctions[WdfDeviceGetHardwareRegisterMappedAddressTableIndex])(WdfDriverGlobals, Device, PseudoBaseAddress); } // // WDF Function: WdfDeviceReadFromHardware // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI SIZE_T (*PFN_WDFDEVICEREADFROMHARDWARE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ WDF_DEVICE_HWACCESS_TARGET_TYPE Type, _In_ WDF_DEVICE_HWACCESS_TARGET_SIZE Size, _In_ PVOID TargetAddress, _Out_writes_all_opt_(Count) PVOID Buffer, _In_opt_ ULONG Count ); _IRQL_requires_max_(PASSIVE_LEVEL) SIZE_T FORCEINLINE WdfDeviceReadFromHardware( _In_ WDFDEVICE Device, _In_ WDF_DEVICE_HWACCESS_TARGET_TYPE Type, _In_ WDF_DEVICE_HWACCESS_TARGET_SIZE Size, _In_ PVOID TargetAddress, _Out_writes_all_opt_(Count) PVOID Buffer, _In_opt_ ULONG Count ) { return ((PFN_WDFDEVICEREADFROMHARDWARE) WdfFunctions[WdfDeviceReadFromHardwareTableIndex])(WdfDriverGlobals, Device, Type, Size, TargetAddress, Buffer, Count); } // // WDF Function: WdfDeviceWriteToHardware // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEWRITETOHARDWARE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ WDF_DEVICE_HWACCESS_TARGET_TYPE Type, _In_ WDF_DEVICE_HWACCESS_TARGET_SIZE Size, _In_ PVOID TargetAddress, _In_ SIZE_T Value, _In_reads_opt_(Count) PVOID Buffer, _In_opt_ ULONG Count ); _IRQL_requires_max_(PASSIVE_LEVEL) VOID FORCEINLINE WdfDeviceWriteToHardware( _In_ WDFDEVICE Device, _In_ WDF_DEVICE_HWACCESS_TARGET_TYPE Type, _In_ WDF_DEVICE_HWACCESS_TARGET_SIZE Size, _In_ PVOID TargetAddress, _In_ SIZE_T Value, _In_reads_opt_(Count) PVOID Buffer, _In_opt_ ULONG Count ) { ((PFN_WDFDEVICEWRITETOHARDWARE) WdfFunctions[WdfDeviceWriteToHardwareTableIndex])(WdfDriverGlobals, Device, Type, Size, TargetAddress, Value, Buffer, Count); } // // WDF Function: WdfDeviceAssignInterfaceProperty // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEASSIGNINTERFACEPROPERTY)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData, _In_ DEVPROPTYPE Type, _In_ ULONG BufferLength, _In_reads_bytes_opt_(BufferLength) PVOID PropertyBuffer ); _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceAssignInterfaceProperty( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData, _In_ DEVPROPTYPE Type, _In_ ULONG BufferLength, _In_reads_bytes_opt_(BufferLength) PVOID PropertyBuffer ) { return ((PFN_WDFDEVICEASSIGNINTERFACEPROPERTY) WdfFunctions[WdfDeviceAssignInterfacePropertyTableIndex])(WdfDriverGlobals, Device, PropertyData, Type, BufferLength, PropertyBuffer); } // // WDF Function: WdfDeviceAllocAndQueryInterfaceProperty // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEALLOCANDQUERYINTERFACEPROPERTY)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData, _In_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY* PropertyMemory, _Out_ PDEVPROPTYPE Type ); _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceAllocAndQueryInterfaceProperty( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData, _In_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY* PropertyMemory, _Out_ PDEVPROPTYPE Type ) { return ((PFN_WDFDEVICEALLOCANDQUERYINTERFACEPROPERTY) WdfFunctions[WdfDeviceAllocAndQueryInterfacePropertyTableIndex])(WdfDriverGlobals, Device, PropertyData, PoolType, PropertyMemoryAttributes, PropertyMemory, Type); } // // WDF Function: WdfDeviceQueryInterfaceProperty // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEQUERYINTERFACEPROPERTY)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData, _In_ ULONG BufferLength, _Out_writes_bytes_opt_(BufferLength) PVOID PropertyBuffer, _Out_ PULONG ResultLength, _Out_ PDEVPROPTYPE Type ); _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS FORCEINLINE WdfDeviceQueryInterfaceProperty( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData, _In_ ULONG BufferLength, _Out_writes_bytes_opt_(BufferLength) PVOID PropertyBuffer, _Out_ PULONG ResultLength, _Out_ PDEVPROPTYPE Type ) { return ((PFN_WDFDEVICEQUERYINTERFACEPROPERTY) WdfFunctions[WdfDeviceQueryInterfacePropertyTableIndex])(WdfDriverGlobals, Device, PropertyData, BufferLength, PropertyBuffer, ResultLength, Type); } // // WDF Function: WdfDeviceGetDeviceStackIoType // typedef _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID (*PFN_WDFDEVICEGETDEVICESTACKIOTYPE)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _Out_ WDF_DEVICE_IO_TYPE* ReadWriteIoType, _Out_ WDF_DEVICE_IO_TYPE* IoControlIoType ); _IRQL_requires_max_(PASSIVE_LEVEL) VOID FORCEINLINE WdfDeviceGetDeviceStackIoType( _In_ WDFDEVICE Device, _Out_ WDF_DEVICE_IO_TYPE* ReadWriteIoType, _Out_ WDF_DEVICE_IO_TYPE* IoControlIoType ) { ((PFN_WDFDEVICEGETDEVICESTACKIOTYPE) WdfFunctions[WdfDeviceGetDeviceStackIoTypeTableIndex])(WdfDriverGlobals, Device, ReadWriteIoType, IoControlIoType); } // // WDF Function: WdfDeviceQueryPropertyEx // typedef _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEQUERYPROPERTYEX)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_PROPERTY_DATA DeviceProperty, _In_ ULONG BufferLength, _Out_ PVOID PropertyBuffer, _Out_ PULONG RequiredSize, _Out_ PDEVPROPTYPE Type ); _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) NTSTATUS FORCEINLINE WdfDeviceQueryPropertyEx( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_PROPERTY_DATA DeviceProperty, _In_ ULONG BufferLength, _Out_ PVOID PropertyBuffer, _Out_ PULONG RequiredSize, _Out_ PDEVPROPTYPE Type ) { return ((PFN_WDFDEVICEQUERYPROPERTYEX) WdfFunctions[WdfDeviceQueryPropertyExTableIndex])(WdfDriverGlobals, Device, DeviceProperty, BufferLength, PropertyBuffer, RequiredSize, Type); } // // WDF Function: WdfDeviceAllocAndQueryPropertyEx // typedef _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEALLOCANDQUERYPROPERTYEX)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_PROPERTY_DATA DeviceProperty, _In_ _Strict_type_match_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY* PropertyMemory, _Out_ PDEVPROPTYPE Type ); _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) NTSTATUS FORCEINLINE WdfDeviceAllocAndQueryPropertyEx( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_PROPERTY_DATA DeviceProperty, _In_ _Strict_type_match_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY* PropertyMemory, _Out_ PDEVPROPTYPE Type ) { return ((PFN_WDFDEVICEALLOCANDQUERYPROPERTYEX) WdfFunctions[WdfDeviceAllocAndQueryPropertyExTableIndex])(WdfDriverGlobals, Device, DeviceProperty, PoolType, PropertyMemoryAttributes, PropertyMemory, Type); } // // WDF Function: WdfDeviceAssignProperty // typedef _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS (*PFN_WDFDEVICEASSIGNPROPERTY)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_PROPERTY_DATA DeviceProperty, _In_ DEVPROPTYPE Type, _In_ ULONG Size, _In_opt_ PVOID Data ); _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) NTSTATUS FORCEINLINE WdfDeviceAssignProperty( _In_ WDFDEVICE Device, _In_ PWDF_DEVICE_PROPERTY_DATA DeviceProperty, _In_ DEVPROPTYPE Type, _In_ ULONG Size, _In_opt_ PVOID Data ) { return ((PFN_WDFDEVICEASSIGNPROPERTY) WdfFunctions[WdfDeviceAssignPropertyTableIndex])(WdfDriverGlobals, Device, DeviceProperty, Type, Size, Data); } WDF_EXTERN_C_END