/*++

Copyright (c) Microsoft Corporation

Module Name:

    FxPnpCallbacks.hpp

Abstract:

    This module implements the PnP/Power callback objects.

Author:



Environment:

    Both kernel and user mode

Revision History:

--*/

#ifndef _FXPNPCALLBACKS_H_
#define _FXPNPCALLBACKS_H_

class FxPnpDeviceFilterResourceRequirements : public FxCallback {

public:
    PFN_WDF_DEVICE_FILTER_RESOURCE_REQUIREMENTS m_Method;

    FxPnpDeviceFilterResourceRequirements(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE Device,
        __in WDFIORESREQLIST Collection
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, Collection);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceD0Entry : public FxCallback {

public:
    PFN_WDF_DEVICE_D0_ENTRY m_Method;

    FxPnpDeviceD0Entry(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device,
        __in WDF_POWER_DEVICE_STATE PreviousState
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, PreviousState);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceD0EntryPostInterruptsEnabled : public FxCallback {

public:
    PFN_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED m_Method;

    FxPnpDeviceD0EntryPostInterruptsEnabled(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device,
        __in WDF_POWER_DEVICE_STATE PreviousState
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, PreviousState);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceD0Exit : public FxCallback {

public:
    PFN_WDF_DEVICE_D0_EXIT m_Method;

    FxPnpDeviceD0Exit(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device,
        __in WDF_POWER_DEVICE_STATE TargetState
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, TargetState);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceD0ExitPreInterruptsDisabled : public FxCallback {

public:
    PFN_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED m_Method;

    FxPnpDeviceD0ExitPreInterruptsDisabled(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device,
        __in WDF_POWER_DEVICE_STATE TargetState
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, TargetState);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDevicePrepareHardware : public FxCallback {

public:
    PFN_WDF_DEVICE_PREPARE_HARDWARE m_Method;

    FxPnpDevicePrepareHardware(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device,
        __in WDFCMRESLIST ResourcesRaw,
        __in WDFCMRESLIST ResourcesTranslated
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, ResourcesRaw, ResourcesTranslated);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceReleaseHardware : public FxCallback {

public:
    PFN_WDF_DEVICE_RELEASE_HARDWARE m_Method;

    FxPnpDeviceReleaseHardware(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device,
        __in WDFCMRESLIST ResourcesTranslated
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, ResourcesTranslated);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceRemoveAddedResources : public FxCallback {
public:
    PFN_WDF_DEVICE_REMOVE_ADDED_RESOURCES m_Method;

public:
    FxPnpDeviceRemoveAddedResources(
        VOID
        )  : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE Device,
        __in WDFCMRESLIST ResourcesRaw,
        __in WDFCMRESLIST ResourcesTranslated
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, ResourcesRaw, ResourcesTranslated);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceSelfManagedIoCleanup : public FxCallback {

public:
    PFN_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP m_Method;

    FxPnpDeviceSelfManagedIoCleanup(
        VOID
        ) : m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in  WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

class FxPnpDeviceSelfManagedIoFlush : public FxCallback {

public:
    PFN_WDF_DEVICE_SELF_MANAGED_IO_FLUSH m_Method;

    FxPnpDeviceSelfManagedIoFlush(
        VOID
        ) : m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in  WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

class FxPnpDeviceSelfManagedIoInit : public FxCallback {

public:
    PFN_WDF_DEVICE_SELF_MANAGED_IO_INIT m_Method;

    FxPnpDeviceSelfManagedIoInit(
        VOID
        ) : m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in  WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceSelfManagedIoSuspend : public FxCallback {

public:
    PFN_WDF_DEVICE_SELF_MANAGED_IO_SUSPEND m_Method;

    FxPnpDeviceSelfManagedIoSuspend(
        VOID
        ) : m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in  WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceSelfManagedIoRestart : public FxCallback {

public:
    PFN_WDF_DEVICE_SELF_MANAGED_IO_RESTART m_Method;

    FxPnpDeviceSelfManagedIoRestart(
        VOID
        ) : m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in  WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceQueryStop : public FxCallback {

public:
    PFN_WDF_DEVICE_QUERY_STOP m_Method;

    FxPnpDeviceQueryStop(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in  WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceQueryRemove : public FxCallback {

public:
    PFN_WDF_DEVICE_QUERY_REMOVE m_Method;

    FxPnpDeviceQueryRemove(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in  WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceResourcesQuery : public FxCallback {

public:
    PFN_WDF_DEVICE_RESOURCES_QUERY m_Method;

    FxPnpDeviceResourcesQuery(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device,
        __in WDFCMRESLIST Collection
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, Collection);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceResourceRequirementsQuery : public FxCallback {

public:
    PFN_WDF_DEVICE_RESOURCE_REQUIREMENTS_QUERY m_Method;

    FxPnpDeviceResourceRequirementsQuery(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device,
        __in WDFIORESREQLIST Collection
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, Collection);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceEject : public FxCallback {

public:
    PFN_WDF_DEVICE_EJECT m_Method;

    FxPnpDeviceEject(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceSurpriseRemoval : public FxCallback {

public:
    PFN_WDF_DEVICE_SURPRISE_REMOVAL m_Method;

    FxPnpDeviceSurpriseRemoval(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE  Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

class FxPnpDeviceUsageNotification : public FxCallback {

public:
    PFN_WDF_DEVICE_USAGE_NOTIFICATION m_Method;

    FxPnpDeviceUsageNotification(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE Device,
        __in WDF_SPECIAL_FILE_TYPE NotificationType,
        __in BOOLEAN InPath
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device, NotificationType, InPath);
            CallbackEnd();
        }
    }
};

class FxPnpDeviceUsageNotificationEx : public FxCallback {

public:
    PFN_WDF_DEVICE_USAGE_NOTIFICATION_EX m_Method;

    FxPnpDeviceUsageNotificationEx(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE Device,
        __in WDF_SPECIAL_FILE_TYPE NotificationType,
        __in BOOLEAN InPath
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, NotificationType, InPath);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPnpDeviceRelationsQuery : public FxCallback {

public:
    PFN_WDF_DEVICE_RELATIONS_QUERY m_Method;

    FxPnpDeviceRelationsQuery(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE Device,
        __in DEVICE_RELATION_TYPE RelationType
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device, RelationType);
            CallbackEnd();
        }
    }
};

class FxPnpDeviceSetLock : public FxCallback {

public:
    PFN_WDF_DEVICE_SET_LOCK m_Method;

    FxPnpDeviceSetLock(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE Device,
        __in BOOLEAN Lock
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device, Lock);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_UNSUCCESSFUL;
        }
    }
};

class FxPnpDeviceReportedMissing : public FxCallback {

public:
    PFN_WDF_DEVICE_REPORTED_MISSING m_Method;

    FxPnpDeviceReportedMissing(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

class FxPowerDeviceEnableWakeAtBus :  public FxCallback {

public:
    PFN_WDF_DEVICE_ENABLE_WAKE_AT_BUS m_Method;

    FxPowerDeviceEnableWakeAtBus(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE Device,
        __in SYSTEM_POWER_STATE PowerState
        )
    {
        NTSTATUS status;

        if (m_Method != NULL) {
            CallbackStart();
            status = m_Method(Device, PowerState);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPowerDeviceDisableWakeAtBus :  public FxCallback {

public:
    PFN_WDF_DEVICE_DISABLE_WAKE_AT_BUS m_Method;

    FxPowerDeviceDisableWakeAtBus(
        VOID
        ) : FxCallback(), m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

class FxPowerDeviceArmWakeFromS0 :  public FxCallback {

public:
    PFN_WDF_DEVICE_ARM_WAKE_FROM_S0 m_Method;

    FxPowerDeviceArmWakeFromS0(
        VOID
        ) : m_Method(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE Device
        )
    {
        if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPowerDeviceArmWakeFromSx :  public FxCallback {

public:
    PFN_WDF_DEVICE_ARM_WAKE_FROM_SX m_Method;
    PFN_WDF_DEVICE_ARM_WAKE_FROM_SX_WITH_REASON m_MethodWithReason;

    FxPowerDeviceArmWakeFromSx(
        VOID
        ) : m_Method(NULL),
            m_MethodWithReason(NULL)
    {
    }

    _Must_inspect_result_
    NTSTATUS
    Invoke(
        __in WDFDEVICE Device,
        __in BOOLEAN DeviceWakeEnabled,
        __in BOOLEAN ChildrenArmedForWake
        )
    {
        if (m_MethodWithReason != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_MethodWithReason(Device,
                                        DeviceWakeEnabled,
                                        ChildrenArmedForWake);
            CallbackEnd();

            return status;
        }
        else if (m_Method != NULL) {
            NTSTATUS status;

            CallbackStart();
            status = m_Method(Device);
            CallbackEnd();

            return status;
        }
        else {
            return STATUS_SUCCESS;
        }
    }
};

class FxPowerDeviceDisarmWakeFromS0 :  public FxCallback {

public:
    PFN_WDF_DEVICE_DISARM_WAKE_FROM_S0 m_Method;

    FxPowerDeviceDisarmWakeFromS0(
        VOID
        ) : m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

class FxPowerDeviceDisarmWakeFromSx :  public FxCallback {

public:
    PFN_WDF_DEVICE_DISARM_WAKE_FROM_SX m_Method;

    FxPowerDeviceDisarmWakeFromSx(
        VOID
        ) : m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

class FxPowerDeviceWakeFromSxTriggered :  public FxCallback {

public:
    PFN_WDF_DEVICE_WAKE_FROM_SX_TRIGGERED m_Method;

    FxPowerDeviceWakeFromSxTriggered(
        VOID
        ) : m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

class FxPowerDeviceWakeFromS0Triggered :  public FxCallback {

public:
    PFN_WDF_DEVICE_WAKE_FROM_S0_TRIGGERED m_Method;

    FxPowerDeviceWakeFromS0Triggered(
        VOID
        ) : m_Method(NULL)
    {
    }

    VOID
    Invoke(
        __in WDFDEVICE Device
        )
    {
        if (m_Method != NULL) {
            CallbackStart();
            m_Method(Device);
            CallbackEnd();
        }
    }
};

struct FxPnpStateCallbackInfo {
    //
    // Bit field of WDF_STATE_NOTIFICATION_TYPE defined values
    //
    ULONG Types;

    //
    // Function to call
    //
    PFN_WDF_DEVICE_PNP_STATE_CHANGE_NOTIFICATION Callback;
};

struct FxPnpStateCallback : public FxCallback {

    FxPnpStateCallback(
        VOID
        ) : FxCallback()
    {
        RtlZeroMemory(&m_Methods[0], sizeof(m_Methods));
    }

    VOID
    Invoke(
        __in WDF_DEVICE_PNP_STATE State,
        __in WDF_STATE_NOTIFICATION_TYPE Type,
        __in WDFDEVICE Device,
        __in PCWDF_DEVICE_PNP_NOTIFICATION_DATA NotificationData
        )
    {
        FxPnpStateCallbackInfo* pInfo;

        pInfo = &m_Methods[WdfDevStateNormalize(State)-WdfDevStatePnpObjectCreated];

        if (pInfo->Callback != NULL && (pInfo->Types & Type)) {
            CallbackStart();
            pInfo->Callback(Device, NotificationData);
            CallbackEnd();
        }
    }

    FxPnpStateCallbackInfo m_Methods[WdfDevStatePnpNull - WdfDevStatePnpObjectCreated];
};

struct FxPowerStateCallbackInfo {
    //
    // Bit field of WDF_STATE_NOTIFICATION_TYPE defined values
    //
    ULONG Types;

    //
    // Function to call
    //
    PFN_WDF_DEVICE_POWER_STATE_CHANGE_NOTIFICATION Callback;
};

struct FxPowerStateCallback : public FxCallback {
    FxPowerStateCallback(
        VOID
        ) : FxCallback()
    {
        RtlZeroMemory(&m_Methods[0], sizeof(m_Methods));
    }

    VOID
    Invoke(
        __in WDF_DEVICE_POWER_STATE State,
        __in WDF_STATE_NOTIFICATION_TYPE Type,
        __in WDFDEVICE Device,
        __in PCWDF_DEVICE_POWER_NOTIFICATION_DATA NotificationData
        )
    {
        FxPowerStateCallbackInfo *pInfo;

        pInfo = &m_Methods[WdfDevStateNormalize(State)-WdfDevStatePowerObjectCreated];

        if (pInfo->Callback != NULL && (pInfo->Types & Type)) {
            CallbackStart();
            pInfo->Callback(Device, NotificationData);
            CallbackEnd();
        }
    }

    FxPowerStateCallbackInfo m_Methods[WdfDevStatePowerNull-WdfDevStatePowerObjectCreated];
};

struct FxPowerPolicyStateCallbackInfo {
    //
    // Bit field of WDF_STATE_NOTIFICATION_TYPE defined values
    //
    ULONG Types;

    //
    // Function to call
    //
    PFN_WDF_DEVICE_POWER_POLICY_STATE_CHANGE_NOTIFICATION Callback;
};

struct FxPowerPolicyStateCallback : public FxCallback {
    FxPowerPolicyStateCallback(
        VOID
        ) : FxCallback()
    {
        RtlZeroMemory(&m_Methods[0], sizeof(m_Methods));
    }

    VOID
    Invoke(
        __in WDF_DEVICE_POWER_POLICY_STATE State,
        __in WDF_STATE_NOTIFICATION_TYPE Type,
        __in WDFDEVICE Device,
        __in PCWDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA NotificationData
        )
    {
        FxPowerPolicyStateCallbackInfo *pInfo;

        pInfo = &m_Methods[WdfDevStateNormalize(State)-WdfDevStatePwrPolObjectCreated];

        if (pInfo->Callback != NULL && (pInfo->Types & Type)) {
            CallbackStart();
            pInfo->Callback(Device, NotificationData);
            CallbackEnd();
        }
    }

    FxPowerPolicyStateCallbackInfo m_Methods[WdfDevStatePwrPolNull-WdfDevStatePwrPolObjectCreated];
};



#endif // _FXPNPCALLBACKS_H_