/*++ Copyright (c) Microsoft Corporation. All rights reserved. Module Name: FxMin.hpp Abstract: This is the minimal version of driver framework include file that is needed to build FxObject Author: Environment: Both kernel and user mode Revision History: --*/ #ifndef _FXMIN_HPP #define _FXMIN_HPP extern "C" { #include "mx.h" } #include "fxmacros.hpp" #if (FX_CORE_MODE == FX_CORE_USER_MODE) // // Undef METHOD_FROM_CTL_CODE so that it is prevented from being used // inadvertently in mode-agnostic code. Irp->GetParameterIoctlCodeBufferMethod // should be used instead. // #ifdef METHOD_FROM_CTL_CODE #undef METHOD_FROM_CTL_CODE #endif #endif // FX_CORE_USER_MODE typedef struct _WDF_BIND_INFO *PWDF_BIND_INFO; extern "C" { /////////////////// // Basic definitions (abridged version of wdf.h) #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 WDF_EXTERN_C_START typedef VOID (*WDFFUNC) (VOID); extern const WDFFUNC *WdfFunctions; #include "wdftypes.h" #include "wdfglobals.h" #include "wdffuncenum.h" #include "wdfstatus.h" #include "wdfassert.h" #include "wdfverifier.h" // generic object #include "wdfobject.h" #include "wdfcore.h" #include "wdfdevice.h" // #include "wdfdevicepri.h" // #include "wdfiotargetpri.h" #include "wdfdriver.h" #include "wdfmemory.h" #include "wdfrequest.h" #include "wdfwmi.h" #include "wdfchildlist.h" #include "wdfpdo.h" #include "wdffdo.h" #include "wdfiotarget.h" #include "wdfcontrol.h" #include "wdfcx.h" #include "wdfio.h" #include "wdfqueryinterface.h" #include "wdfworkitem.h" #include "wdfcollection.h" #include "wdffileobject.h" #include "wdfinterrupt.h" #include "wdfregistry.h" #include "wdfresource.h" #include "wdfstring.h" #include "wdfsync.h" #include "wdftimer.h" #if (FX_CORE_MODE == FX_CORE_USER_MODE) #include "wdfhid.h" #endif // #pragma warning(disable:4200) // suppress nameless struct/union warning // #pragma warning(disable:4201) // suppress nameless struct/union warning // #pragma warning(disable:4214) // suppress bit field types other than int warning #include #include #include "wdfusb.h" #include #include #include #include "wdfbugcodes.h" WDF_EXTERN_C_END #if (FX_CORE_MODE == FX_CORE_USER_MODE) #define KMDF_ONLY_CODE_PATH_ASSERT() FX_VERIFY(INTERNAL, TRAPMSG("Not implemented")); #define UMDF_ONLY_CODE_PATH_ASSERT() #else #define KMDF_ONLY_CODE_PATH_ASSERT() #define UMDF_ONLY_CODE_PATH_ASSERT() ASSERTMSG("Not implemented for KMDF", FALSE); #endif // // Since C does not have strong type checking we must invent our own // typedef struct _WDF_OBJECT_CONTEXT_TYPE_INFO_V1_0 { // // The size of this structure in bytes // ULONG Size; // // String representation of the context's type name, i.e. "DEVICE_CONTEXT" // PCHAR ContextName; // // The size of the context in bytes. This will be the size of the context // associated with the handle unless // WDF_OBJECT_ATTRIBUTES::ContextSizeOverride is specified. // size_t ContextSize; } WDF_OBJECT_CONTEXT_TYPE_INFO_V1_0, *PWDF_OBJECT_CONTEXT_TYPE_INFO_V1_0; typedef struct _WDF_OBJECT_CONTEXT_TYPE_INFO_V1_0 *PWDF_OBJECT_CONTEXT_TYPE_INFO_V1_0; // #include "cobbled.hpp" } //extern "C" #include #include #include #include #if FX_CORE_MODE==FX_CORE_USER_MODE typedef enum _TRACE_INFORMATION_CLASS { TraceIdClass, TraceHandleClass, TraceEnableFlagsClass, TraceEnableLevelClass, GlobalLoggerHandleClass, EventLoggerHandleClass, AllLoggerHandlesClass, TraceHandleByNameClass, LoggerEventsLostClass, TraceSessionSettingsClass, MaxTraceInformationClass } TRACE_INFORMATION_CLASS; #include #endif // FX_CORE_MODE==FX_CORE_USER_MODE #include "fxforward.hpp" #if (FX_CORE_MODE == FX_CORE_USER_MODE) #include "hostfxutil.h" #include "wdfplatform.h" #include "wdfplatformimpl.h" #include "debug.h" #include "devreg.h" #include "wudfx_namespace_on.h" #include "wudfx.h" #include "wudfx_namespace_off.h" #include "driverframeworks-usermode-umevents.h" #endif #include "fxtypedefs.hpp" #if defined(EVENT_TRACING) #include "fxwmicompat.h" #include "fxtrace.h" #else #include "dbgtrace.h" #endif // EVENT_TRACING #include "fxtypes.h" #include "fxrequestcontexttypes.h" #include "fxpool.h" #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) #include "fxglobalskm.h" #include "fxperftracekm.hpp" // #include "DriverFrameworks-KernelMode-KmEvents.h" #else #include "fxglobalsum.h" #endif #include "fxpoolinlines.hpp" #include "fxverifier.h" #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) #include "fxverifierkm.h" #else #include "fxverifierum.h" #include "device_common.h" #endif #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) #include "fxmdl.h" #endif #include "fxprobeandlock.h" //#include "FxPerfTraceKm.hpp" //#include #include "fxstump.hpp" #include "fxrequestbuffer.hpp" #include "fxtagtracker.hpp" // internal locks #include "fxverifierlock.hpp" #include "fxlock.hpp" // base objects #include "fxobject.hpp" #include "fxpagedobject.hpp" #include "fxnonpagedobject.hpp" #include "fxhandle.h" // external locks #include "fxwaitlock.hpp" //#include "FxSpinLock.hpp" // utitilty classes and functions #include "fxtransactionedlist.hpp" #include "fxrelateddevicelist.hpp" #include "fxdisposelist.hpp" #include "fxcollection.hpp" #include "stringutil.hpp" // abstract classes #include "ifxhascallbacks.hpp" // callback delegation and locking #include "fxsystemthread.hpp" #include "fxsystemworkitem.hpp" #include "fxcallbacklock.hpp" #include "fxcallbackspinlock.hpp" #include "fxcallbackmutexlock.hpp" #include "fxcallback.hpp" #include "fxsystemthread.hpp" #include "ifxmemory.hpp" #include "fxlookasidelist.hpp" //#include "fxnpagedlookasidelist.hpp" //#include "fxpagedlookasidelist.hpp" #include "fxmemoryobject.hpp" #include "fxmemorybuffer.hpp" #include "fxmemorybufferfrompool.hpp" #include "fxmemorybufferpreallocated.hpp" //#include "fxmemorybufferfromlookaside.hpp" #include "fxrequestmemory.hpp" #include "fxregkey.hpp" #include "fxautoregistry.hpp" #include "fxautostring.hpp" #include "fxstring.hpp" #include "fxvalidatefunctions.hpp" #include "fxresource.hpp" #include "fxrelateddevice.hpp" #include "fxdeviceinterface.hpp" #include "fxqueryinterface.hpp" #include "fxdevicetext.hpp" #if (FX_CORE_MODE == FX_CORE_USER_MODE) #include "fxirpum.hpp" #include "fxinterruptthreadpoolum.hpp" #else #include "fxirpkm.hpp" #endif #include "fxdriver.hpp" // generic package interface #include "fxpackage.hpp" #include "fxpkggeneral.hpp" #include "fxdefaultirphandler.hpp" //#include "fxpoxkm.hpp" #include "fxpkgpnp.hpp" #include "fxwatchdog.hpp" // Device supportfx #include "fxchildlist.hpp" #include "fxcxdeviceinfo.hpp" #include "fxdevice.hpp" #include "fxpkgio.hpp" #include "fxdevicetomxinterface.hpp" #include "fxirpqueue.hpp" #include "fxrequestcontext.hpp" #include "fxrequestcallbacks.hpp" #include "fxrequestbase.hpp" #include "fxrequest.hpp" #include "fxsyncrequest.hpp" #include "fxrequestvalidatefunctions.hpp" // specialized irp handlers (ie packages) #include "fxpkgfdo.hpp" #include "fxpkgpdo.hpp" //#include "fxwmiirphandler.hpp" //#include "fxwmiprovider.hpp" //#include "fxwmiinstance.hpp" // queus for read, write, (internal) IOCTL #include "fxioqueue.hpp" #include "fxfileobject.hpp" #include "fxirppreprocessinfo.hpp" #include "fxirpdynamicdispatchinfo.hpp" //#include "fxdpc.hpp" #include "fxworkitem.hpp" #include "fxtimer.hpp" #if FX_CORE_MODE==FX_CORE_USER_MODE #include "fxinterruptum.hpp" #include "fxmessagedispatchum.hpp" #else #include "fxinterruptkm.hpp" #endif // IO targets (device lower edge interface) #include "fxiotarget.hpp" #include "fxiotargetremote.hpp" #include "fxiotargetself.hpp" #include "fxusbdevice.hpp" #include "fxusbinterface.hpp" #include "fxusbpipe.hpp" // DMA support //#include "fxdmaenabler.hpp" //#include "fxdmatransaction.hpp" //#include "fxcommonbuffer.hpp" // Triage info. // #include "wdftriage.h" #include "fxpkgioshared.hpp" #if FX_CORE_MODE==FX_CORE_USER_MODE #include "ufxverifier.h" #endif #endif // _FXMIN_HPP