diff --git a/sdk/lib/drivers/CMakeLists.txt b/sdk/lib/drivers/CMakeLists.txt index 7f63a0026cb..e20501a0cf0 100644 --- a/sdk/lib/drivers/CMakeLists.txt +++ b/sdk/lib/drivers/CMakeLists.txt @@ -11,3 +11,4 @@ add_subdirectory(rdbsslib) add_subdirectory(rtlver) add_subdirectory(rxce) add_subdirectory(sound) +add_subdirectory(wdf) diff --git a/sdk/lib/drivers/wdf/CMakeLists.txt b/sdk/lib/drivers/wdf/CMakeLists.txt new file mode 100644 index 00000000000..8b4efe8c3b5 --- /dev/null +++ b/sdk/lib/drivers/wdf/CMakeLists.txt @@ -0,0 +1,217 @@ + +remove_definitions(-D_WIN32_WINNT=0x502) + +list(APPEND SOURCE_SHARED + shared/core/fxcxdeviceinit.cpp + # shared/core/fxcxdeviceinitapi.cpp + shared/core/fxdevice.cpp + shared/core/fxdeviceapi.cpp + shared/core/fxdevicebase.cpp + shared/core/fxdevicecontrolapi.cpp + shared/core/fxdeviceinit.cpp + shared/core/fxdeviceinitapi.cpp + shared/core/fxdisposelist.cpp + shared/core/fxdriver.cpp + shared/core/fxdriverapi.cpp + shared/core/fxfileobject.cpp + shared/core/fxfileobjectapi.cpp + shared/core/fxirpqueue.cpp + # shared/core/fxlock.cpp + shared/core/fxlookasidelist.cpp + shared/core/fxlookasidelistapi.cpp + shared/core/fxmemorybuffer.cpp + shared/core/fxmemorybufferapi.cpp + shared/core/fxmemorybufferfromlookaside.cpp + shared/core/fxmemorybufferfrompool.cpp + shared/core/fxmemorybufferpreallocated.cpp + shared/core/fxmemorybufferpreallocatedapi.cpp + shared/core/fxmemoryobject.cpp + shared/core/fxpagedlookasidelist.cpp + shared/core/fxrequest.cpp + shared/core/fxrequestapi.cpp + shared/core/fxrequestbase.cpp + shared/core/fxrequestcontext.cpp + shared/core/fxrequestmemory.cpp + shared/core/fxrequestoutputbuffer.cpp + shared/core/fxrequestsystembuffer.cpp + shared/core/fxsyncrequest.cpp + shared/core/fxsystemworkitem.cpp + shared/core/fxtimer.cpp + shared/core/fxtimerapi.cpp + shared/core/fxworkitem.cpp + shared/core/fxworkitemapi.cpp + # shared/core/verifierapi.cpp + shared/irphandlers/default/fxdefaultirphandler.cpp + shared/irphandlers/general/fxpkggeneral.cpp + shared/irphandlers/io/fxioqueue.cpp + shared/irphandlers/io/fxioqueueapi.cpp + shared/irphandlers/io/fxpkgio.cpp + shared/irphandlers/package/fxpackage.cpp + # shared/irphandlers/pnp/devicepwrreqstatemachine.cpp + shared/irphandlers/pnp/eventqueue.cpp + shared/irphandlers/pnp/fdopower.cpp + # shared/irphandlers/pnp/fxinterruptapi.cpp + shared/irphandlers/pnp/fxpkgfdo.cpp + shared/irphandlers/pnp/fxpkgpdo.cpp + shared/irphandlers/pnp/fxpkgpnp.cpp + shared/irphandlers/pnp/interruptobject.cpp + shared/irphandlers/pnp/notpowerpolicyownerstatemachine.cpp + shared/irphandlers/pnp/pdopower.cpp + shared/irphandlers/pnp/pnpstatemachine.cpp + shared/irphandlers/pnp/poweridlestatemachine.cpp + shared/irphandlers/pnp/powerpolicystatemachine.cpp + shared/irphandlers/pnp/powerstatemachine.cpp + shared/irphandlers/pnp/poxinterface.cpp # stubs + shared/irphandlers/pnp/selfmanagediostatemachine.cpp + shared/irphandlers/pnp/wakeinterruptstatemachine.cpp + shared/object/dbgtrace.cpp + shared/object/fxobject.cpp + shared/object/fxobjectapi.cpp + shared/object/fxobjectstatemachine.cpp + shared/object/fxtagtracker.cpp + shared/object/fxuserobject.cpp + shared/object/fxuserobjectapi.cpp + shared/object/fxvalidatefunctions.cpp + shared/object/fxverifierbugcheck.cpp + shared/object/fxverifierlock.cpp + shared/object/globals.cpp + shared/object/handleapi.cpp + shared/object/wdfpool.cpp + shared/support/fxcollection.cpp + shared/support/fxcollectionapi.cpp + # shared/support/fxdeviceinterface.cpp + shared/support/fxdeviceinterfaceapi.cpp + shared/support/fxdevicetext.cpp + shared/support/fxregistryapi.cpp + shared/support/fxregkey.cpp + shared/support/fxrequestbuffer.cpp + # shared/support/fxresourceapi.cpp + shared/support/fxresourcecollection.cpp + shared/support/fxspinlock.cpp + shared/support/fxspinlockapi.cpp + shared/support/fxstring.cpp + shared/support/fxstringapi.cpp + # shared/support/fxtelemetry.cpp + shared/support/fxtransactionedlist.cpp + shared/support/fxwaitlock.cpp + shared/support/fxwaitlockapi.cpp + shared/support/stringutil.cpp + shared/targets/general/fxiotarget.cpp + shared/targets/general/fxiotargetapi.cpp + shared/targets/general/fxiotargetremote.cpp + shared/targets/general/fxiotargetself.cpp + # shared/targets/usb/fxusbdevice.cpp + # shared/targets/usb/fxusbdeviceapi.cpp + # shared/targets/usb/fxusbinterface.cpp + # shared/targets/usb/fxusbinterfaceapi.cpp + # shared/targets/usb/fxusbpipe.cpp + # shared/targets/usb/fxusbpipeapi.cpp + # shared/targets/usb/usbutil.cpp + ) + +list(APPEND SOURCE_KM + kmdf/src/core/fxbugcheckcallback.cpp + kmdf/src/core/fxchildlist.cpp + kmdf/src/core/fxchildlistapi.cpp + kmdf/src/core/fxdevicefdoapi.cpp + kmdf/src/core/fxdevicepdoapi.cpp + kmdf/src/core/fxdpc.cpp + kmdf/src/core/fxdpcapi.cpp + kmdf/src/core/fxsystemthread.cpp + # kmdf/src/core/tracing.cpp + # kmdf/src/dma/base/fxcommonbuffer.cpp # requires DMA stuff + # kmdf/src/dma/base/fxcommonbufferapi.cpp # requires DMA stuff + # kmdf/src/dma/base/fxdmaenabler.cpp + # kmdf/src/dma/base/fxdmaenablerapi.cpp + # kmdf/src/dma/base/fxdmatransaction.cpp + # kmdf/src/dma/base/fxdmatransactionapi.cpp + # kmdf/src/dynamic/version/version.cpp + kmdf/src/fxtosharedinterface/fxobject/fxobjectinfokm.cpp + # kmdf/src/irphandlers/wmi/fxwmiapi.cpp + # kmdf/src/irphandlers/wmi/fxwmiinstance.cpp + # kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp + # kmdf/src/irphandlers/wmi/fxwmiprovider.cpp + # kmdf/src/librarycommon/fxlibrarycommon.cpp + kmdf/src/support/fxqueryinterface.cpp + kmdf/src/support/fxqueryinterfaceapi.cpp + kmdf/src/support/fxrelateddevice.cpp + kmdf/src/support/fxrelateddevicelist.cpp + kmdf/src/support/probeandlock.c + shared/core/km/fxdeviceapikm.cpp + shared/core/km/fxdevicebasekm.cpp + shared/core/km/fxdeviceinitkm.cpp + shared/core/km/fxdevicekm.cpp + shared/core/km/fxdriverapikm.cpp + shared/core/km/fxdriverkm.cpp + shared/core/km/fxfileobjectapikm.cpp + shared/core/km/fxfileobjectkm.cpp + shared/core/km/fxnpagedlookasidelistkm.cpp + shared/core/km/fxrequestkm.cpp + shared/core/km/fxrequestsystembufferkm.cpp + shared/irphandlers/io/km/fxioqueuekm.cpp + shared/irphandlers/pnp/km/eventqueuekm.cpp + shared/irphandlers/pnp/km/fxpkgfdokm.cpp + shared/irphandlers/pnp/km/fxpkgpdokm.cpp + shared/irphandlers/pnp/km/fxpkgpnpkm.cpp + shared/irphandlers/pnp/km/interruptobjectkm.cpp + shared/irphandlers/pnp/km/pnpstatemachinekm.cpp + shared/irphandlers/pnp/km/powerpolicystatemachinekm.cpp + shared/irphandlers/pnp/km/powerstatemachinekm.cpp # stubs + # shared/irphandlers/pnp/km/poxinterfacekm.cpp + shared/irphandlers/pnp/km/supportkm.cpp + shared/object/km/fxobjectkm.cpp + shared/object/km/globalskm.cpp + shared/object/km/wdfpoolkm.cpp + shared/primitives/km/mxgeneralkm.cpp + shared/support/km/fxdeviceinterfacekm.cpp + shared/support/km/fxregkeykm.cpp + shared/support/km/fxrequestbufferkm.cpp + shared/support/km/fxresourcecollectionkm.cpp + # shared/support/km/fxtelemetrykm.cpp + shared/targets/general/fxiotarget.cpp + shared/targets/general/fxiotargetapi.cpp + shared/targets/general/fxiotargetremote.cpp + shared/targets/general/fxiotargetself.cpp + shared/targets/general/km/fxiotargetapikm.cpp + shared/targets/general/km/fxiotargetkm.cpp + shared/targets/general/km/fxiotargetremotekm.cpp + reactos_special.cpp + ) + +# add_library(wdf01000 MODULE ${SOURCE}) + +# set_module_type(wdf01000 kernelmodedriver ENTRYPOINT 0) +# add_importlibs(wdf01000 ntoskrnl hal wdfldr) +# add_cd_file(TARGET wdf01000 DESTINATION reactos/system32/drivers FOR all) +# add_registry_inf(wdf01000_reg.inf) + +add_library(wdf01000 ${SOURCE_SHARED} ${SOURCE_KM}) + +target_compile_definitions(wdf01000 + PUBLIC WDF_DEVICE_NO_WDMSEC_H _WIN32_WINNT=0x603 NTDDI_VERSION=0x06030000 # NTDDI_WINBLUE + PRIVATE FX_CORE_MODE=1 FX_CORE_KERNEL_MODE=1 + PRIVATE __WDF_MAJOR_VERSION=1 __WDF_MINOR_VERSION=17 __WDF_BUILD_NUMBER=7600) + +target_include_directories(wdf01000 + PUBLIC ${REACTOS_SOURCE_DIR}/sdk/include/wdf/kmdf/1.17 + PRIVATE + shared/inc/primitives/common + shared/inc/primitives/km + shared/inc/private/common + shared/inc/private/km + kmdf/inc/private + shared/object # fxobjectpch.hpp + shared/support # fxsupportpch.hpp + shared/core # coreprivshared.hpp + shared/irphandlers # irphandlerspriv.hpp + shared/irphandlers/pnp # pnppriv.hpp + shared/irphandlers/pnp/km # pnpprivkm.hpp + ) + +target_link_libraries(wdf01000 ntoskrnl_vista ${PSEH_LIB}) + +if(GCC) + target_compile_options(wdf01000 + PRIVATE -Wno-write-strings -Wno-unknown-pragmas -Wno-switch + PRIVATE $<$:-Wno-reorder -Wno-invalid-offsetof -Wno-delete-non-virtual-dtor>) +endif() diff --git a/sdk/lib/drivers/wdf/kmdf/inc/private/fx.hpp b/sdk/lib/drivers/wdf/kmdf/inc/private/fx.hpp index d3eae97629e..637715c5699 100644 --- a/sdk/lib/drivers/wdf/kmdf/inc/private/fx.hpp +++ b/sdk/lib/drivers/wdf/kmdf/inc/private/fx.hpp @@ -28,19 +28,19 @@ extern "C" { #include "mx.h" } -#include "FxMacros.hpp" +#include "fxmacros.hpp" extern "C" { #include "wdf.h" -#include "wdmsec.h" +// #include "wdmsec.h" #include "wdmguid.h" -#include "wdfdevicepri.h" -#include "wdfiotargetpri.h" +// #include "wdfdevicepri.h" +// #include "wdfiotargetpri.h" #include "wdfcx.h" #include "wdfldr.h" -#include +#include #include "wdf10.h" #include "wdf11.h" @@ -57,152 +57,158 @@ extern "C" { // Integer overflow functions #include "ntintsafe.h" -#include "FxForward.hpp" +#include "fxforward.hpp" //KMDF defines for shared type names -#include "FxTypeDefsKm.hpp" +#include "fxtypedefskm.hpp" +// #include "fxwmicompat.h" +// #include "fxtrace.h" +#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" -#include "FxGlobalsKM.h" -#include "FxPoolInlines.hpp" +#include "fxglobalskm.h" +#include "fxpoolinlines.hpp" #include "fxverifier.h" #include "fxverifierkm.h" -#include "FxMdl.h" -#include "FxProbeAndLock.h" +#include "fxmdl.h" +#include "fxprobeandlock.h" -#include "FxPerfTraceKm.hpp" -#include "DriverFrameworks-KernelMode-KmEvents.h" +#include "fxperftracekm.hpp" +// #include "DriverFrameworks-KernelMode-KmEvents.h" -#include +#include -#include "FxStump.hpp" +#include "fxstump.hpp" -#include "FxRequestBuffer.hpp" +#include "fxrequestbuffer.hpp" -#include "FxTagTracker.hpp" +#include "fxtagtracker.hpp" // internal locks -#include "FxVerifierLock.hpp" -#include "FxLock.hpp" +#include "fxverifierlock.hpp" +#include "fxlock.hpp" // base objects #include "fxobject.hpp" -#include "FxPagedObject.hpp" -#include "FxNonPagedObject.hpp" +#include "fxpagedobject.hpp" +#include "fxnonpagedobject.hpp" #include "fxhandle.h" // external locks -#include "FxWaitLock.hpp" -#include "FxSpinLock.hpp" +#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" +#include "fxtransactionedlist.hpp" +#include "fxrelateddevicelist.hpp" +#include "fxdisposelist.hpp" +#include "fxcollection.hpp" +#include "stringutil.hpp" // abstract classes -#include "IFxHasCallbacks.hpp" +#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 "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 "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 "FxRequestValidateFunctions.hpp" +#include "fxvalidatefunctions.hpp" +#include "fxrequestvalidatefunctions.hpp" -#include "FxResource.hpp" -#include "FxRelatedDevice.hpp" -#include "FxDeviceInterface.hpp" -#include "FxQueryInterface.hpp" -#include "FxDeviceText.hpp" +#include "fxresource.hpp" +#include "fxrelateddevice.hpp" +#include "fxdeviceinterface.hpp" +#include "fxqueryinterface.hpp" +#include "fxdevicetext.hpp" -#include "FxIrp.hpp" -#include "FxDriver.hpp" +#include "fxirp.hpp" +#include "fxdriver.hpp" // generic package interface -#include "FxPackage.hpp" -#include "FxPkgGeneral.hpp" -#include "FxDefaultIrpHandler.hpp" -#include "FxPkgPnp.hpp" -#include "FxWatchDog.hpp" +#include "fxpackage.hpp" +#include "fxpkggeneral.hpp" +#include "fxdefaultirphandler.hpp" +#include "fxpkgpnp.hpp" +#include "fxwatchdog.hpp" // Device support -#include "FxChildList.hpp" -#include "FxCxDeviceInfo.hpp" -#include "FxDevice.hpp" +#include "fxchildlist.hpp" +#include "fxcxdeviceinfo.hpp" +#include "fxdevice.hpp" -#include "FxPkgIo.hpp" +#include "fxpkgio.hpp" -#include "FxDeviceToMxInterface.hpp" +#include "fxdevicetomxinterface.hpp" -#include "FxIrpQueue.hpp" -#include "FxRequestContext.hpp" -#include "FxRequestCallbacks.hpp" -#include "FxRequestBase.hpp" -#include "FxRequest.hpp" -#include "FxSyncRequest.hpp" +#include "fxirpqueue.hpp" +#include "fxrequestcontext.hpp" +#include "fxrequestcallbacks.hpp" +#include "fxrequestbase.hpp" +#include "fxrequest.hpp" +#include "fxsyncrequest.hpp" // specialized irp handlers (ie packages) -#include "FxPkgFdo.hpp" -#include "FxPkgPdo.hpp" -#include "FxWmiIrpHandler.hpp" -#include "FxWmiProvider.hpp" -#include "FxWmiInstance.hpp" +#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 "fxioqueue.hpp" +#include "fxfileobject.hpp" +#include "fxirppreprocessinfo.hpp" +#include "fxirpdynamicdispatchinfo.hpp" -#include "FxDpc.hpp" -#include "FxWorkItem.hpp" -#include "FxTimer.hpp" -#include "FxInterruptKm.hpp" +#include "fxdpc.hpp" +#include "fxworkitem.hpp" +#include "fxtimer.hpp" +#include "fxinterruptkm.hpp" // IO targets (device lower edge interface) -#include "FxIoTarget.hpp" -#include "FxIoTargetRemote.hpp" -#include "FxIoTargetSelf.hpp" +#include "fxiotarget.hpp" +#include "fxiotargetremote.hpp" +#include "fxiotargetself.hpp" -#include "FxUsbDevice.hpp" -#include "FxUsbInterface.hpp" -#include "FxUsbPipe.hpp" +#include "fxusbdevice.hpp" +#include "fxusbinterface.hpp" +#include "fxusbpipe.hpp" // DMA support -#include "FxDmaEnabler.hpp" -#include "FxDmaTransaction.hpp" -#include "FxCommonBuffer.hpp" +#include "fxdmaenabler.hpp" +#include "fxdmatransaction.hpp" +#include "fxcommonbuffer.hpp" // Triage info. -#include "wdftriage.h" +// #include "wdftriage.h" -#include "FxTelemetry.hpp" +#include "fxtelemetry.hpp" #endif // _FX_H diff --git a/sdk/lib/drivers/wdf/kmdf/inc/private/fxdmatransaction.hpp b/sdk/lib/drivers/wdf/kmdf/inc/private/fxdmatransaction.hpp index 0e3535b669c..9774fafec57 100644 --- a/sdk/lib/drivers/wdf/kmdf/inc/private/fxdmatransaction.hpp +++ b/sdk/lib/drivers/wdf/kmdf/inc/private/fxdmatransaction.hpp @@ -5,15 +5,15 @@ #define _FXDMATRANSACTION_HPP_ extern "C" { -#include "FxDmaTransaction.hpp.tmh" +// #include "FxDmaTransaction.hpp.tmh" } -#include "FxDmaTransactionCallbacks.hpp" +#include "fxdmatransactioncallbacks.hpp" // // This type is used to allocate scatter-gather list of 1 element on the stack. // -typedef __declspec(align(MEMORY_ALLOCATION_ALIGNMENT))UCHAR UCHAR_MEMORY_ALIGNED; +typedef DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) UCHAR UCHAR_MEMORY_ALIGNED; // begin_wpp enum @@ -912,6 +912,7 @@ protected: protected: inline + void SetMapRegisterBase( __in PVOID Value ) @@ -924,6 +925,7 @@ protected: } inline + void ClearMapRegisterBase( VOID ) @@ -934,6 +936,7 @@ protected: } inline + BOOLEAN IsMapRegisterBaseSet( VOID ) @@ -1005,6 +1008,7 @@ protected: static IO_ALLOCATION_ACTION + STDCALL _AdapterControl( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp, @@ -1528,7 +1532,7 @@ protected: VOID ) { - __super::Reuse(); + FxDmaPacketTransaction::Reuse(); // __super call m_ConfigureChannelFunction.Method = NULL; m_ConfigureChannelContext = NULL; diff --git a/sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamics.h b/sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamics.h index 35a3564dab3..fcf73d3722b 100644 --- a/sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamics.h +++ b/sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamics.h @@ -14,6 +14,14 @@ Environment: #ifndef _FXDYNAMICS_H_ #define _FXDYNAMICS_H_ +typedef WDFAPI NTSTATUS +(STDCALL *PFN_ROSWDFUNIMPLEMENTED)(VOID); + +WDFAPI +NTSTATUS +STDCALL +WdfApiNotImplemented(); + typedef struct _WDFFUNCTIONS { @@ -38,10 +46,15 @@ typedef struct _WDFFUNCTIONS { PFN_WDFCOLLECTIONGETITEM pfnWdfCollectionGetItem; PFN_WDFCOLLECTIONGETFIRSTITEM pfnWdfCollectionGetFirstItem; PFN_WDFCOLLECTIONGETLASTITEM pfnWdfCollectionGetLastItem; - PFN_WDFCOMMONBUFFERCREATE pfnWdfCommonBufferCreate; - PFN_WDFCOMMONBUFFERGETALIGNEDVIRTUALADDRESS pfnWdfCommonBufferGetAlignedVirtualAddress; - PFN_WDFCOMMONBUFFERGETALIGNEDLOGICALADDRESS pfnWdfCommonBufferGetAlignedLogicalAddress; - PFN_WDFCOMMONBUFFERGETLENGTH pfnWdfCommonBufferGetLength; + // PFN_WDFCOMMONBUFFERCREATE pfnWdfCommonBufferCreate; + // PFN_WDFCOMMONBUFFERGETALIGNEDVIRTUALADDRESS pfnWdfCommonBufferGetAlignedVirtualAddress; + // PFN_WDFCOMMONBUFFERGETALIGNEDLOGICALADDRESS pfnWdfCommonBufferGetAlignedLogicalAddress; + // PFN_WDFCOMMONBUFFERGETLENGTH pfnWdfCommonBufferGetLength; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferCreate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferGetAlignedVirtualAddress; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferGetAlignedLogicalAddress; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferGetLength; + PFN_WDFCONTROLDEVICEINITALLOCATE pfnWdfControlDeviceInitAllocate; PFN_WDFCONTROLDEVICEINITSETSHUTDOWNNOTIFICATION pfnWdfControlDeviceInitSetShutdownNotification; PFN_WDFCONTROLFINISHINITIALIZING pfnWdfControlFinishInitializing; @@ -111,23 +124,41 @@ typedef struct _WDFFUNCTIONS { PFN_WDFDEVICEENQUEUEREQUEST pfnWdfDeviceEnqueueRequest; PFN_WDFDEVICEGETDEFAULTQUEUE pfnWdfDeviceGetDefaultQueue; PFN_WDFDEVICECONFIGUREREQUESTDISPATCHING pfnWdfDeviceConfigureRequestDispatching; - PFN_WDFDMAENABLERCREATE pfnWdfDmaEnablerCreate; - PFN_WDFDMAENABLERGETMAXIMUMLENGTH pfnWdfDmaEnablerGetMaximumLength; - PFN_WDFDMAENABLERGETMAXIMUMSCATTERGATHERELEMENTS pfnWdfDmaEnablerGetMaximumScatterGatherElements; - PFN_WDFDMAENABLERSETMAXIMUMSCATTERGATHERELEMENTS pfnWdfDmaEnablerSetMaximumScatterGatherElements; - PFN_WDFDMATRANSACTIONCREATE pfnWdfDmaTransactionCreate; - PFN_WDFDMATRANSACTIONINITIALIZE pfnWdfDmaTransactionInitialize; - PFN_WDFDMATRANSACTIONINITIALIZEUSINGREQUEST pfnWdfDmaTransactionInitializeUsingRequest; - PFN_WDFDMATRANSACTIONEXECUTE pfnWdfDmaTransactionExecute; - PFN_WDFDMATRANSACTIONRELEASE pfnWdfDmaTransactionRelease; - PFN_WDFDMATRANSACTIONDMACOMPLETED pfnWdfDmaTransactionDmaCompleted; - PFN_WDFDMATRANSACTIONDMACOMPLETEDWITHLENGTH pfnWdfDmaTransactionDmaCompletedWithLength; - PFN_WDFDMATRANSACTIONDMACOMPLETEDFINAL pfnWdfDmaTransactionDmaCompletedFinal; - PFN_WDFDMATRANSACTIONGETBYTESTRANSFERRED pfnWdfDmaTransactionGetBytesTransferred; - PFN_WDFDMATRANSACTIONSETMAXIMUMLENGTH pfnWdfDmaTransactionSetMaximumLength; - PFN_WDFDMATRANSACTIONGETREQUEST pfnWdfDmaTransactionGetRequest; - PFN_WDFDMATRANSACTIONGETCURRENTDMATRANSFERLENGTH pfnWdfDmaTransactionGetCurrentDmaTransferLength; - PFN_WDFDMATRANSACTIONGETDEVICE pfnWdfDmaTransactionGetDevice; + // PFN_WDFDMAENABLERCREATE pfnWdfDmaEnablerCreate; + // PFN_WDFDMAENABLERGETMAXIMUMLENGTH pfnWdfDmaEnablerGetMaximumLength; + // PFN_WDFDMAENABLERGETMAXIMUMSCATTERGATHERELEMENTS pfnWdfDmaEnablerGetMaximumScatterGatherElements; + // PFN_WDFDMAENABLERSETMAXIMUMSCATTERGATHERELEMENTS pfnWdfDmaEnablerSetMaximumScatterGatherElements; + // PFN_WDFDMATRANSACTIONCREATE pfnWdfDmaTransactionCreate; + // PFN_WDFDMATRANSACTIONINITIALIZE pfnWdfDmaTransactionInitialize; + // PFN_WDFDMATRANSACTIONINITIALIZEUSINGREQUEST pfnWdfDmaTransactionInitializeUsingRequest; + // PFN_WDFDMATRANSACTIONEXECUTE pfnWdfDmaTransactionExecute; + // PFN_WDFDMATRANSACTIONRELEASE pfnWdfDmaTransactionRelease; + // PFN_WDFDMATRANSACTIONDMACOMPLETED pfnWdfDmaTransactionDmaCompleted; + // PFN_WDFDMATRANSACTIONDMACOMPLETEDWITHLENGTH pfnWdfDmaTransactionDmaCompletedWithLength; + // PFN_WDFDMATRANSACTIONDMACOMPLETEDFINAL pfnWdfDmaTransactionDmaCompletedFinal; + // PFN_WDFDMATRANSACTIONGETBYTESTRANSFERRED pfnWdfDmaTransactionGetBytesTransferred; + // PFN_WDFDMATRANSACTIONSETMAXIMUMLENGTH pfnWdfDmaTransactionSetMaximumLength; + // PFN_WDFDMATRANSACTIONGETREQUEST pfnWdfDmaTransactionGetRequest; + // PFN_WDFDMATRANSACTIONGETCURRENTDMATRANSFERLENGTH pfnWdfDmaTransactionGetCurrentDmaTransferLength; + // PFN_WDFDMATRANSACTIONGETDEVICE pfnWdfDmaTransactionGetDevice; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerCreate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerGetMaximumLength; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerGetMaximumScatterGatherElements; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerSetMaximumScatterGatherElements; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionCreate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionInitialize; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionInitializeUsingRequest; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionExecute; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionRelease; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionDmaCompleted; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionDmaCompletedWithLength; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionDmaCompletedFinal; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetBytesTransferred; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetMaximumLength; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetRequest; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetCurrentDmaTransferLength; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetDevice; + PFN_WDFDPCCREATE pfnWdfDpcCreate; PFN_WDFDPCENQUEUE pfnWdfDpcEnqueue; PFN_WDFDPCCANCEL pfnWdfDpcCancel; @@ -158,17 +189,29 @@ typedef struct _WDFFUNCTIONS { PFN_WDFFILEOBJECTGETFLAGS pfnWdfFileObjectGetFlags; PFN_WDFFILEOBJECTGETDEVICE pfnWdfFileObjectGetDevice; PFN_WDFFILEOBJECTWDMGETFILEOBJECT pfnWdfFileObjectWdmGetFileObject; - PFN_WDFINTERRUPTCREATE pfnWdfInterruptCreate; - PFN_WDFINTERRUPTQUEUEDPCFORISR pfnWdfInterruptQueueDpcForIsr; - PFN_WDFINTERRUPTSYNCHRONIZE pfnWdfInterruptSynchronize; - PFN_WDFINTERRUPTACQUIRELOCK pfnWdfInterruptAcquireLock; - PFN_WDFINTERRUPTRELEASELOCK pfnWdfInterruptReleaseLock; - PFN_WDFINTERRUPTENABLE pfnWdfInterruptEnable; - PFN_WDFINTERRUPTDISABLE pfnWdfInterruptDisable; - PFN_WDFINTERRUPTWDMGETINTERRUPT pfnWdfInterruptWdmGetInterrupt; - PFN_WDFINTERRUPTGETINFO pfnWdfInterruptGetInfo; - PFN_WDFINTERRUPTSETPOLICY pfnWdfInterruptSetPolicy; - PFN_WDFINTERRUPTGETDEVICE pfnWdfInterruptGetDevice; + // PFN_WDFINTERRUPTCREATE pfnWdfInterruptCreate; + // PFN_WDFINTERRUPTQUEUEDPCFORISR pfnWdfInterruptQueueDpcForIsr; + // PFN_WDFINTERRUPTSYNCHRONIZE pfnWdfInterruptSynchronize; + // PFN_WDFINTERRUPTACQUIRELOCK pfnWdfInterruptAcquireLock; + // PFN_WDFINTERRUPTRELEASELOCK pfnWdfInterruptReleaseLock; + // PFN_WDFINTERRUPTENABLE pfnWdfInterruptEnable; + // PFN_WDFINTERRUPTDISABLE pfnWdfInterruptDisable; + // PFN_WDFINTERRUPTWDMGETINTERRUPT pfnWdfInterruptWdmGetInterrupt; + // PFN_WDFINTERRUPTGETINFO pfnWdfInterruptGetInfo; + // PFN_WDFINTERRUPTSETPOLICY pfnWdfInterruptSetPolicy; + // PFN_WDFINTERRUPTGETDEVICE pfnWdfInterruptGetDevice; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptCreate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptQueueDpcForIsr; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptSynchronize; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptAcquireLock; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptReleaseLock; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptEnable; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptDisable; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptWdmGetInterrupt; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptGetInfo; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptSetPolicy; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptGetDevice; + PFN_WDFIOQUEUECREATE pfnWdfIoQueueCreate; PFN_WDFIOQUEUEGETSTATE pfnWdfIoQueueGetState; PFN_WDFIOQUEUESTART pfnWdfIoQueueStart; @@ -303,28 +346,51 @@ typedef struct _WDFFUNCTIONS { PFN_WDFREQUESTREQUEUE pfnWdfRequestRequeue; PFN_WDFREQUESTSTOPACKNOWLEDGE pfnWdfRequestStopAcknowledge; PFN_WDFREQUESTWDMGETIRP pfnWdfRequestWdmGetIrp; - PFN_WDFIORESOURCEREQUIREMENTSLISTSETSLOTNUMBER pfnWdfIoResourceRequirementsListSetSlotNumber; - PFN_WDFIORESOURCEREQUIREMENTSLISTSETINTERFACETYPE pfnWdfIoResourceRequirementsListSetInterfaceType; - PFN_WDFIORESOURCEREQUIREMENTSLISTAPPENDIORESLIST pfnWdfIoResourceRequirementsListAppendIoResList; - PFN_WDFIORESOURCEREQUIREMENTSLISTINSERTIORESLIST pfnWdfIoResourceRequirementsListInsertIoResList; - PFN_WDFIORESOURCEREQUIREMENTSLISTGETCOUNT pfnWdfIoResourceRequirementsListGetCount; - PFN_WDFIORESOURCEREQUIREMENTSLISTGETIORESLIST pfnWdfIoResourceRequirementsListGetIoResList; - PFN_WDFIORESOURCEREQUIREMENTSLISTREMOVE pfnWdfIoResourceRequirementsListRemove; - PFN_WDFIORESOURCEREQUIREMENTSLISTREMOVEBYIORESLIST pfnWdfIoResourceRequirementsListRemoveByIoResList; - PFN_WDFIORESOURCELISTCREATE pfnWdfIoResourceListCreate; - PFN_WDFIORESOURCELISTAPPENDDESCRIPTOR pfnWdfIoResourceListAppendDescriptor; - PFN_WDFIORESOURCELISTINSERTDESCRIPTOR pfnWdfIoResourceListInsertDescriptor; - PFN_WDFIORESOURCELISTUPDATEDESCRIPTOR pfnWdfIoResourceListUpdateDescriptor; - PFN_WDFIORESOURCELISTGETCOUNT pfnWdfIoResourceListGetCount; - PFN_WDFIORESOURCELISTGETDESCRIPTOR pfnWdfIoResourceListGetDescriptor; - PFN_WDFIORESOURCELISTREMOVE pfnWdfIoResourceListRemove; - PFN_WDFIORESOURCELISTREMOVEBYDESCRIPTOR pfnWdfIoResourceListRemoveByDescriptor; - PFN_WDFCMRESOURCELISTAPPENDDESCRIPTOR pfnWdfCmResourceListAppendDescriptor; - PFN_WDFCMRESOURCELISTINSERTDESCRIPTOR pfnWdfCmResourceListInsertDescriptor; - PFN_WDFCMRESOURCELISTGETCOUNT pfnWdfCmResourceListGetCount; - PFN_WDFCMRESOURCELISTGETDESCRIPTOR pfnWdfCmResourceListGetDescriptor; - PFN_WDFCMRESOURCELISTREMOVE pfnWdfCmResourceListRemove; - PFN_WDFCMRESOURCELISTREMOVEBYDESCRIPTOR pfnWdfCmResourceListRemoveByDescriptor; + // PFN_WDFIORESOURCEREQUIREMENTSLISTSETSLOTNUMBER pfnWdfIoResourceRequirementsListSetSlotNumber; + // PFN_WDFIORESOURCEREQUIREMENTSLISTSETINTERFACETYPE pfnWdfIoResourceRequirementsListSetInterfaceType; + // PFN_WDFIORESOURCEREQUIREMENTSLISTAPPENDIORESLIST pfnWdfIoResourceRequirementsListAppendIoResList; + // PFN_WDFIORESOURCEREQUIREMENTSLISTINSERTIORESLIST pfnWdfIoResourceRequirementsListInsertIoResList; + // PFN_WDFIORESOURCEREQUIREMENTSLISTGETCOUNT pfnWdfIoResourceRequirementsListGetCount; + // PFN_WDFIORESOURCEREQUIREMENTSLISTGETIORESLIST pfnWdfIoResourceRequirementsListGetIoResList; + // PFN_WDFIORESOURCEREQUIREMENTSLISTREMOVE pfnWdfIoResourceRequirementsListRemove; + // PFN_WDFIORESOURCEREQUIREMENTSLISTREMOVEBYIORESLIST pfnWdfIoResourceRequirementsListRemoveByIoResList; + // PFN_WDFIORESOURCELISTCREATE pfnWdfIoResourceListCreate; + // PFN_WDFIORESOURCELISTAPPENDDESCRIPTOR pfnWdfIoResourceListAppendDescriptor; + // PFN_WDFIORESOURCELISTINSERTDESCRIPTOR pfnWdfIoResourceListInsertDescriptor; + // PFN_WDFIORESOURCELISTUPDATEDESCRIPTOR pfnWdfIoResourceListUpdateDescriptor; + // PFN_WDFIORESOURCELISTGETCOUNT pfnWdfIoResourceListGetCount; + // PFN_WDFIORESOURCELISTGETDESCRIPTOR pfnWdfIoResourceListGetDescriptor; + // PFN_WDFIORESOURCELISTREMOVE pfnWdfIoResourceListRemove; + // PFN_WDFIORESOURCELISTREMOVEBYDESCRIPTOR pfnWdfIoResourceListRemoveByDescriptor; + // PFN_WDFCMRESOURCELISTAPPENDDESCRIPTOR pfnWdfCmResourceListAppendDescriptor; + // PFN_WDFCMRESOURCELISTINSERTDESCRIPTOR pfnWdfCmResourceListInsertDescriptor; + // PFN_WDFCMRESOURCELISTGETCOUNT pfnWdfCmResourceListGetCount; + // PFN_WDFCMRESOURCELISTGETDESCRIPTOR pfnWdfCmResourceListGetDescriptor; + // PFN_WDFCMRESOURCELISTREMOVE pfnWdfCmResourceListRemove; + // PFN_WDFCMRESOURCELISTREMOVEBYDESCRIPTOR pfnWdfCmResourceListRemoveByDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListSetSlotNumber; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListSetInterfaceType; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListAppendIoResList; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListInsertIoResList; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListGetCount; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListGetIoResList; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListRemove; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListRemoveByIoResList; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListCreate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListAppendDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListInsertDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListUpdateDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListGetCount; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListGetDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListRemove; + PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListRemoveByDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListAppendDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListInsertDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListGetCount; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListGetDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListRemove; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListRemoveByDescriptor; + PFN_WDFSTRINGCREATE pfnWdfStringCreate; PFN_WDFSTRINGGETUNICODESTRING pfnWdfStringGetUnicodeString; PFN_WDFOBJECTACQUIRELOCK pfnWdfObjectAcquireLock; @@ -339,116 +405,213 @@ typedef struct _WDFFUNCTIONS { PFN_WDFTIMERSTART pfnWdfTimerStart; PFN_WDFTIMERSTOP pfnWdfTimerStop; PFN_WDFTIMERGETPARENTOBJECT pfnWdfTimerGetParentObject; - PFN_WDFUSBTARGETDEVICECREATE pfnWdfUsbTargetDeviceCreate; - PFN_WDFUSBTARGETDEVICERETRIEVEINFORMATION pfnWdfUsbTargetDeviceRetrieveInformation; - PFN_WDFUSBTARGETDEVICEGETDEVICEDESCRIPTOR pfnWdfUsbTargetDeviceGetDeviceDescriptor; - PFN_WDFUSBTARGETDEVICERETRIEVECONFIGDESCRIPTOR pfnWdfUsbTargetDeviceRetrieveConfigDescriptor; - PFN_WDFUSBTARGETDEVICEQUERYSTRING pfnWdfUsbTargetDeviceQueryString; - PFN_WDFUSBTARGETDEVICEALLOCANDQUERYSTRING pfnWdfUsbTargetDeviceAllocAndQueryString; - PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORSTRING pfnWdfUsbTargetDeviceFormatRequestForString; - PFN_WDFUSBTARGETDEVICEGETNUMINTERFACES pfnWdfUsbTargetDeviceGetNumInterfaces; - PFN_WDFUSBTARGETDEVICESELECTCONFIG pfnWdfUsbTargetDeviceSelectConfig; - PFN_WDFUSBTARGETDEVICEWDMGETCONFIGURATIONHANDLE pfnWdfUsbTargetDeviceWdmGetConfigurationHandle; - PFN_WDFUSBTARGETDEVICERETRIEVECURRENTFRAMENUMBER pfnWdfUsbTargetDeviceRetrieveCurrentFrameNumber; - PFN_WDFUSBTARGETDEVICESENDCONTROLTRANSFERSYNCHRONOUSLY pfnWdfUsbTargetDeviceSendControlTransferSynchronously; - PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORCONTROLTRANSFER pfnWdfUsbTargetDeviceFormatRequestForControlTransfer; - PFN_WDFUSBTARGETDEVICEISCONNECTEDSYNCHRONOUS pfnWdfUsbTargetDeviceIsConnectedSynchronous; - PFN_WDFUSBTARGETDEVICERESETPORTSYNCHRONOUSLY pfnWdfUsbTargetDeviceResetPortSynchronously; - PFN_WDFUSBTARGETDEVICECYCLEPORTSYNCHRONOUSLY pfnWdfUsbTargetDeviceCyclePortSynchronously; - PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORCYCLEPORT pfnWdfUsbTargetDeviceFormatRequestForCyclePort; - PFN_WDFUSBTARGETDEVICESENDURBSYNCHRONOUSLY pfnWdfUsbTargetDeviceSendUrbSynchronously; - PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORURB pfnWdfUsbTargetDeviceFormatRequestForUrb; - PFN_WDFUSBTARGETPIPEGETINFORMATION pfnWdfUsbTargetPipeGetInformation; - PFN_WDFUSBTARGETPIPEISINENDPOINT pfnWdfUsbTargetPipeIsInEndpoint; - PFN_WDFUSBTARGETPIPEISOUTENDPOINT pfnWdfUsbTargetPipeIsOutEndpoint; - PFN_WDFUSBTARGETPIPEGETTYPE pfnWdfUsbTargetPipeGetType; - PFN_WDFUSBTARGETPIPESETNOMAXIMUMPACKETSIZECHECK pfnWdfUsbTargetPipeSetNoMaximumPacketSizeCheck; - PFN_WDFUSBTARGETPIPEWRITESYNCHRONOUSLY pfnWdfUsbTargetPipeWriteSynchronously; - PFN_WDFUSBTARGETPIPEFORMATREQUESTFORWRITE pfnWdfUsbTargetPipeFormatRequestForWrite; - PFN_WDFUSBTARGETPIPEREADSYNCHRONOUSLY pfnWdfUsbTargetPipeReadSynchronously; - PFN_WDFUSBTARGETPIPEFORMATREQUESTFORREAD pfnWdfUsbTargetPipeFormatRequestForRead; - PFN_WDFUSBTARGETPIPECONFIGCONTINUOUSREADER pfnWdfUsbTargetPipeConfigContinuousReader; - PFN_WDFUSBTARGETPIPEABORTSYNCHRONOUSLY pfnWdfUsbTargetPipeAbortSynchronously; - PFN_WDFUSBTARGETPIPEFORMATREQUESTFORABORT pfnWdfUsbTargetPipeFormatRequestForAbort; - PFN_WDFUSBTARGETPIPERESETSYNCHRONOUSLY pfnWdfUsbTargetPipeResetSynchronously; - PFN_WDFUSBTARGETPIPEFORMATREQUESTFORRESET pfnWdfUsbTargetPipeFormatRequestForReset; - PFN_WDFUSBTARGETPIPESENDURBSYNCHRONOUSLY pfnWdfUsbTargetPipeSendUrbSynchronously; - PFN_WDFUSBTARGETPIPEFORMATREQUESTFORURB pfnWdfUsbTargetPipeFormatRequestForUrb; - PFN_WDFUSBINTERFACEGETINTERFACENUMBER pfnWdfUsbInterfaceGetInterfaceNumber; - PFN_WDFUSBINTERFACEGETNUMENDPOINTS pfnWdfUsbInterfaceGetNumEndpoints; - PFN_WDFUSBINTERFACEGETDESCRIPTOR pfnWdfUsbInterfaceGetDescriptor; - PFN_WDFUSBINTERFACESELECTSETTING pfnWdfUsbInterfaceSelectSetting; - PFN_WDFUSBINTERFACEGETENDPOINTINFORMATION pfnWdfUsbInterfaceGetEndpointInformation; - PFN_WDFUSBTARGETDEVICEGETINTERFACE pfnWdfUsbTargetDeviceGetInterface; - PFN_WDFUSBINTERFACEGETCONFIGUREDSETTINGINDEX pfnWdfUsbInterfaceGetConfiguredSettingIndex; - PFN_WDFUSBINTERFACEGETNUMCONFIGUREDPIPES pfnWdfUsbInterfaceGetNumConfiguredPipes; - PFN_WDFUSBINTERFACEGETCONFIGUREDPIPE pfnWdfUsbInterfaceGetConfiguredPipe; - PFN_WDFUSBTARGETPIPEWDMGETPIPEHANDLE pfnWdfUsbTargetPipeWdmGetPipeHandle; - PFN_WDFVERIFIERDBGBREAKPOINT pfnWdfVerifierDbgBreakPoint; - PFN_WDFVERIFIERKEBUGCHECK pfnWdfVerifierKeBugCheck; - PFN_WDFWMIPROVIDERCREATE pfnWdfWmiProviderCreate; - PFN_WDFWMIPROVIDERGETDEVICE pfnWdfWmiProviderGetDevice; - PFN_WDFWMIPROVIDERISENABLED pfnWdfWmiProviderIsEnabled; - PFN_WDFWMIPROVIDERGETTRACINGHANDLE pfnWdfWmiProviderGetTracingHandle; - PFN_WDFWMIINSTANCECREATE pfnWdfWmiInstanceCreate; - PFN_WDFWMIINSTANCEREGISTER pfnWdfWmiInstanceRegister; - PFN_WDFWMIINSTANCEDEREGISTER pfnWdfWmiInstanceDeregister; - PFN_WDFWMIINSTANCEGETDEVICE pfnWdfWmiInstanceGetDevice; - PFN_WDFWMIINSTANCEGETPROVIDER pfnWdfWmiInstanceGetProvider; - PFN_WDFWMIINSTANCEFIREEVENT pfnWdfWmiInstanceFireEvent; + // PFN_WDFUSBTARGETDEVICECREATE pfnWdfUsbTargetDeviceCreate; + // PFN_WDFUSBTARGETDEVICERETRIEVEINFORMATION pfnWdfUsbTargetDeviceRetrieveInformation; + // PFN_WDFUSBTARGETDEVICEGETDEVICEDESCRIPTOR pfnWdfUsbTargetDeviceGetDeviceDescriptor; + // PFN_WDFUSBTARGETDEVICERETRIEVECONFIGDESCRIPTOR pfnWdfUsbTargetDeviceRetrieveConfigDescriptor; + // PFN_WDFUSBTARGETDEVICEQUERYSTRING pfnWdfUsbTargetDeviceQueryString; + // PFN_WDFUSBTARGETDEVICEALLOCANDQUERYSTRING pfnWdfUsbTargetDeviceAllocAndQueryString; + // PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORSTRING pfnWdfUsbTargetDeviceFormatRequestForString; + // PFN_WDFUSBTARGETDEVICEGETNUMINTERFACES pfnWdfUsbTargetDeviceGetNumInterfaces; + // PFN_WDFUSBTARGETDEVICESELECTCONFIG pfnWdfUsbTargetDeviceSelectConfig; + // PFN_WDFUSBTARGETDEVICEWDMGETCONFIGURATIONHANDLE pfnWdfUsbTargetDeviceWdmGetConfigurationHandle; + // PFN_WDFUSBTARGETDEVICERETRIEVECURRENTFRAMENUMBER pfnWdfUsbTargetDeviceRetrieveCurrentFrameNumber; + // PFN_WDFUSBTARGETDEVICESENDCONTROLTRANSFERSYNCHRONOUSLY pfnWdfUsbTargetDeviceSendControlTransferSynchronously; + // PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORCONTROLTRANSFER pfnWdfUsbTargetDeviceFormatRequestForControlTransfer; + // PFN_WDFUSBTARGETDEVICEISCONNECTEDSYNCHRONOUS pfnWdfUsbTargetDeviceIsConnectedSynchronous; + // PFN_WDFUSBTARGETDEVICERESETPORTSYNCHRONOUSLY pfnWdfUsbTargetDeviceResetPortSynchronously; + // PFN_WDFUSBTARGETDEVICECYCLEPORTSYNCHRONOUSLY pfnWdfUsbTargetDeviceCyclePortSynchronously; + // PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORCYCLEPORT pfnWdfUsbTargetDeviceFormatRequestForCyclePort; + // PFN_WDFUSBTARGETDEVICESENDURBSYNCHRONOUSLY pfnWdfUsbTargetDeviceSendUrbSynchronously; + // PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORURB pfnWdfUsbTargetDeviceFormatRequestForUrb; + // PFN_WDFUSBTARGETPIPEGETINFORMATION pfnWdfUsbTargetPipeGetInformation; + // PFN_WDFUSBTARGETPIPEISINENDPOINT pfnWdfUsbTargetPipeIsInEndpoint; + // PFN_WDFUSBTARGETPIPEISOUTENDPOINT pfnWdfUsbTargetPipeIsOutEndpoint; + // PFN_WDFUSBTARGETPIPEGETTYPE pfnWdfUsbTargetPipeGetType; + // PFN_WDFUSBTARGETPIPESETNOMAXIMUMPACKETSIZECHECK pfnWdfUsbTargetPipeSetNoMaximumPacketSizeCheck; + // PFN_WDFUSBTARGETPIPEWRITESYNCHRONOUSLY pfnWdfUsbTargetPipeWriteSynchronously; + // PFN_WDFUSBTARGETPIPEFORMATREQUESTFORWRITE pfnWdfUsbTargetPipeFormatRequestForWrite; + // PFN_WDFUSBTARGETPIPEREADSYNCHRONOUSLY pfnWdfUsbTargetPipeReadSynchronously; + // PFN_WDFUSBTARGETPIPEFORMATREQUESTFORREAD pfnWdfUsbTargetPipeFormatRequestForRead; + // PFN_WDFUSBTARGETPIPECONFIGCONTINUOUSREADER pfnWdfUsbTargetPipeConfigContinuousReader; + // PFN_WDFUSBTARGETPIPEABORTSYNCHRONOUSLY pfnWdfUsbTargetPipeAbortSynchronously; + // PFN_WDFUSBTARGETPIPEFORMATREQUESTFORABORT pfnWdfUsbTargetPipeFormatRequestForAbort; + // PFN_WDFUSBTARGETPIPERESETSYNCHRONOUSLY pfnWdfUsbTargetPipeResetSynchronously; + // PFN_WDFUSBTARGETPIPEFORMATREQUESTFORRESET pfnWdfUsbTargetPipeFormatRequestForReset; + // PFN_WDFUSBTARGETPIPESENDURBSYNCHRONOUSLY pfnWdfUsbTargetPipeSendUrbSynchronously; + // PFN_WDFUSBTARGETPIPEFORMATREQUESTFORURB pfnWdfUsbTargetPipeFormatRequestForUrb; + // PFN_WDFUSBINTERFACEGETINTERFACENUMBER pfnWdfUsbInterfaceGetInterfaceNumber; + // PFN_WDFUSBINTERFACEGETNUMENDPOINTS pfnWdfUsbInterfaceGetNumEndpoints; + // PFN_WDFUSBINTERFACEGETDESCRIPTOR pfnWdfUsbInterfaceGetDescriptor; + // PFN_WDFUSBINTERFACESELECTSETTING pfnWdfUsbInterfaceSelectSetting; + // PFN_WDFUSBINTERFACEGETENDPOINTINFORMATION pfnWdfUsbInterfaceGetEndpointInformation; + // PFN_WDFUSBTARGETDEVICEGETINTERFACE pfnWdfUsbTargetDeviceGetInterface; + // PFN_WDFUSBINTERFACEGETCONFIGUREDSETTINGINDEX pfnWdfUsbInterfaceGetConfiguredSettingIndex; + // PFN_WDFUSBINTERFACEGETNUMCONFIGUREDPIPES pfnWdfUsbInterfaceGetNumConfiguredPipes; + // PFN_WDFUSBINTERFACEGETCONFIGUREDPIPE pfnWdfUsbInterfaceGetConfiguredPipe; + // PFN_WDFUSBTARGETPIPEWDMGETPIPEHANDLE pfnWdfUsbTargetPipeWdmGetPipeHandle; + // PFN_WDFVERIFIERDBGBREAKPOINT pfnWdfVerifierDbgBreakPoint; + // PFN_WDFVERIFIERKEBUGCHECK pfnWdfVerifierKeBugCheck; + // PFN_WDFWMIPROVIDERCREATE pfnWdfWmiProviderCreate; + // PFN_WDFWMIPROVIDERGETDEVICE pfnWdfWmiProviderGetDevice; + // PFN_WDFWMIPROVIDERISENABLED pfnWdfWmiProviderIsEnabled; + // PFN_WDFWMIPROVIDERGETTRACINGHANDLE pfnWdfWmiProviderGetTracingHandle; + // PFN_WDFWMIINSTANCECREATE pfnWdfWmiInstanceCreate; + // PFN_WDFWMIINSTANCEREGISTER pfnWdfWmiInstanceRegister; + // PFN_WDFWMIINSTANCEDEREGISTER pfnWdfWmiInstanceDeregister; + // PFN_WDFWMIINSTANCEGETDEVICE pfnWdfWmiInstanceGetDevice; + // PFN_WDFWMIINSTANCEGETPROVIDER pfnWdfWmiInstanceGetProvider; + // PFN_WDFWMIINSTANCEFIREEVENT pfnWdfWmiInstanceFireEvent; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCreate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceRetrieveInformation; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceGetDeviceDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceRetrieveConfigDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceQueryString; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceAllocAndQueryString; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceFormatRequestForString; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceGetNumInterfaces; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceSelectConfig; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceWdmGetConfigurationHandle; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceRetrieveCurrentFrameNumber; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceSendControlTransferSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceFormatRequestForControlTransfer; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceIsConnectedSynchronous; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceResetPortSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCyclePortSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceFormatRequestForCyclePort; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceSendUrbSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceFormatRequestForUrb; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeGetInformation; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeIsInEndpoint; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeIsOutEndpoint; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeGetType; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeSetNoMaximumPacketSizeCheck; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeWriteSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForWrite; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeReadSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForRead; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeConfigContinuousReader; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeAbortSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForAbort; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeResetSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForReset; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeSendUrbSynchronously; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForUrb; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetInterfaceNumber; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetNumEndpoints; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetDescriptor; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceSelectSetting; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetEndpointInformation; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceGetInterface; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetConfiguredSettingIndex; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetNumConfiguredPipes; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetConfiguredPipe; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeWdmGetPipeHandle; + PFN_ROSWDFUNIMPLEMENTED pfnWdfVerifierDbgBreakPoint; + PFN_ROSWDFUNIMPLEMENTED pfnWdfVerifierKeBugCheck; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiProviderCreate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiProviderGetDevice; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiProviderIsEnabled; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiProviderGetTracingHandle; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceCreate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceRegister; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceDeregister; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceGetDevice; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceGetProvider; + PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceFireEvent; + PFN_WDFWORKITEMCREATE pfnWdfWorkItemCreate; PFN_WDFWORKITEMENQUEUE pfnWdfWorkItemEnqueue; PFN_WDFWORKITEMGETPARENTOBJECT pfnWdfWorkItemGetParentObject; PFN_WDFWORKITEMFLUSH pfnWdfWorkItemFlush; - PFN_WDFCOMMONBUFFERCREATEWITHCONFIG pfnWdfCommonBufferCreateWithConfig; - PFN_WDFDMAENABLERGETFRAGMENTLENGTH pfnWdfDmaEnablerGetFragmentLength; - PFN_WDFDMAENABLERWDMGETDMAADAPTER pfnWdfDmaEnablerWdmGetDmaAdapter; - PFN_WDFUSBINTERFACEGETNUMSETTINGS pfnWdfUsbInterfaceGetNumSettings; + // PFN_WDFCOMMONBUFFERCREATEWITHCONFIG pfnWdfCommonBufferCreateWithConfig; + // PFN_WDFDMAENABLERGETFRAGMENTLENGTH pfnWdfDmaEnablerGetFragmentLength; + // PFN_WDFDMAENABLERWDMGETDMAADAPTER pfnWdfDmaEnablerWdmGetDmaAdapter; + // PFN_WDFUSBINTERFACEGETNUMSETTINGS pfnWdfUsbInterfaceGetNumSettings; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferCreateWithConfig; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerGetFragmentLength; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerWdmGetDmaAdapter; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetNumSettings; + PFN_WDFDEVICEREMOVEDEPENDENTUSAGEDEVICEOBJECT pfnWdfDeviceRemoveDependentUsageDeviceObject; PFN_WDFDEVICEGETSYSTEMPOWERACTION pfnWdfDeviceGetSystemPowerAction; - PFN_WDFINTERRUPTSETEXTENDEDPOLICY pfnWdfInterruptSetExtendedPolicy; + // PFN_WDFINTERRUPTSETEXTENDEDPOLICY pfnWdfInterruptSetExtendedPolicy; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptSetExtendedPolicy; + PFN_WDFIOQUEUEASSIGNFORWARDPROGRESSPOLICY pfnWdfIoQueueAssignForwardProgressPolicy; PFN_WDFPDOINITASSIGNCONTAINERID pfnWdfPdoInitAssignContainerID; PFN_WDFPDOINITALLOWFORWARDINGREQUESTTOPARENT pfnWdfPdoInitAllowForwardingRequestToParent; PFN_WDFREQUESTMARKCANCELABLEEX pfnWdfRequestMarkCancelableEx; PFN_WDFREQUESTISRESERVED pfnWdfRequestIsReserved; PFN_WDFREQUESTFORWARDTOPARENTDEVICEIOQUEUE pfnWdfRequestForwardToParentDeviceIoQueue; - PFN_WDFCXDEVICEINITALLOCATE pfnWdfCxDeviceInitAllocate; - PFN_WDFCXDEVICEINITASSIGNWDMIRPPREPROCESSCALLBACK pfnWdfCxDeviceInitAssignWdmIrpPreprocessCallback; - PFN_WDFCXDEVICEINITSETIOINCALLERCONTEXTCALLBACK pfnWdfCxDeviceInitSetIoInCallerContextCallback; - PFN_WDFCXDEVICEINITSETREQUESTATTRIBUTES pfnWdfCxDeviceInitSetRequestAttributes; - PFN_WDFCXDEVICEINITSETFILEOBJECTCONFIG pfnWdfCxDeviceInitSetFileObjectConfig; + // PFN_WDFCXDEVICEINITALLOCATE pfnWdfCxDeviceInitAllocate; + // PFN_WDFCXDEVICEINITASSIGNWDMIRPPREPROCESSCALLBACK pfnWdfCxDeviceInitAssignWdmIrpPreprocessCallback; + // PFN_WDFCXDEVICEINITSETIOINCALLERCONTEXTCALLBACK pfnWdfCxDeviceInitSetIoInCallerContextCallback; + // PFN_WDFCXDEVICEINITSETREQUESTATTRIBUTES pfnWdfCxDeviceInitSetRequestAttributes; + // PFN_WDFCXDEVICEINITSETFILEOBJECTCONFIG pfnWdfCxDeviceInitSetFileObjectConfig; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitAllocate; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitAssignWdmIrpPreprocessCallback; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitSetIoInCallerContextCallback; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitSetRequestAttributes; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitSetFileObjectConfig; + PFN_WDFDEVICEWDMDISPATCHIRP pfnWdfDeviceWdmDispatchIrp; PFN_WDFDEVICEWDMDISPATCHIRPTOIOQUEUE pfnWdfDeviceWdmDispatchIrpToIoQueue; PFN_WDFDEVICEINITSETREMOVELOCKOPTIONS pfnWdfDeviceInitSetRemoveLockOptions; PFN_WDFDEVICECONFIGUREWDMIRPDISPATCHCALLBACK pfnWdfDeviceConfigureWdmIrpDispatchCallback; - PFN_WDFDMAENABLERCONFIGURESYSTEMPROFILE pfnWdfDmaEnablerConfigureSystemProfile; - PFN_WDFDMATRANSACTIONINITIALIZEUSINGOFFSET pfnWdfDmaTransactionInitializeUsingOffset; - PFN_WDFDMATRANSACTIONGETTRANSFERINFO pfnWdfDmaTransactionGetTransferInfo; - PFN_WDFDMATRANSACTIONSETCHANNELCONFIGURATIONCALLBACK pfnWdfDmaTransactionSetChannelConfigurationCallback; - PFN_WDFDMATRANSACTIONSETTRANSFERCOMPLETECALLBACK pfnWdfDmaTransactionSetTransferCompleteCallback; - PFN_WDFDMATRANSACTIONSETIMMEDIATEEXECUTION pfnWdfDmaTransactionSetImmediateExecution; - PFN_WDFDMATRANSACTIONALLOCATERESOURCES pfnWdfDmaTransactionAllocateResources; - PFN_WDFDMATRANSACTIONSETDEVICEADDRESSOFFSET pfnWdfDmaTransactionSetDeviceAddressOffset; - PFN_WDFDMATRANSACTIONFREERESOURCES pfnWdfDmaTransactionFreeResources; - PFN_WDFDMATRANSACTIONCANCEL pfnWdfDmaTransactionCancel; - PFN_WDFDMATRANSACTIONWDMGETTRANSFERCONTEXT pfnWdfDmaTransactionWdmGetTransferContext; - PFN_WDFINTERRUPTQUEUEWORKITEMFORISR pfnWdfInterruptQueueWorkItemForIsr; - PFN_WDFINTERRUPTTRYTOACQUIRELOCK pfnWdfInterruptTryToAcquireLock; + // PFN_WDFDMAENABLERCONFIGURESYSTEMPROFILE pfnWdfDmaEnablerConfigureSystemProfile; + // PFN_WDFDMATRANSACTIONINITIALIZEUSINGOFFSET pfnWdfDmaTransactionInitializeUsingOffset; + // PFN_WDFDMATRANSACTIONGETTRANSFERINFO pfnWdfDmaTransactionGetTransferInfo; + // PFN_WDFDMATRANSACTIONSETCHANNELCONFIGURATIONCALLBACK pfnWdfDmaTransactionSetChannelConfigurationCallback; + // PFN_WDFDMATRANSACTIONSETTRANSFERCOMPLETECALLBACK pfnWdfDmaTransactionSetTransferCompleteCallback; + // PFN_WDFDMATRANSACTIONSETIMMEDIATEEXECUTION pfnWdfDmaTransactionSetImmediateExecution; + // PFN_WDFDMATRANSACTIONALLOCATERESOURCES pfnWdfDmaTransactionAllocateResources; + // PFN_WDFDMATRANSACTIONSETDEVICEADDRESSOFFSET pfnWdfDmaTransactionSetDeviceAddressOffset; + // PFN_WDFDMATRANSACTIONFREERESOURCES pfnWdfDmaTransactionFreeResources; + // PFN_WDFDMATRANSACTIONCANCEL pfnWdfDmaTransactionCancel; + // PFN_WDFDMATRANSACTIONWDMGETTRANSFERCONTEXT pfnWdfDmaTransactionWdmGetTransferContext; + // PFN_WDFINTERRUPTQUEUEWORKITEMFORISR pfnWdfInterruptQueueWorkItemForIsr; + // PFN_WDFINTERRUPTTRYTOACQUIRELOCK pfnWdfInterruptTryToAcquireLock; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerConfigureSystemProfile; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionInitializeUsingOffset; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetTransferInfo; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetChannelConfigurationCallback; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetTransferCompleteCallback; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetImmediateExecution; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionAllocateResources; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetDeviceAddressOffset; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionFreeResources; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionCancel; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionWdmGetTransferContext; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptQueueWorkItemForIsr; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptTryToAcquireLock; + PFN_WDFIOQUEUESTOPANDPURGE pfnWdfIoQueueStopAndPurge; PFN_WDFIOQUEUESTOPANDPURGESYNCHRONOUSLY pfnWdfIoQueueStopAndPurgeSynchronously; PFN_WDFIOTARGETPURGE pfnWdfIoTargetPurge; - PFN_WDFUSBTARGETDEVICECREATEWITHPARAMETERS pfnWdfUsbTargetDeviceCreateWithParameters; - PFN_WDFUSBTARGETDEVICEQUERYUSBCAPABILITY pfnWdfUsbTargetDeviceQueryUsbCapability; - PFN_WDFUSBTARGETDEVICECREATEURB pfnWdfUsbTargetDeviceCreateUrb; - PFN_WDFUSBTARGETDEVICECREATEISOCHURB pfnWdfUsbTargetDeviceCreateIsochUrb; + // PFN_WDFUSBTARGETDEVICECREATEWITHPARAMETERS pfnWdfUsbTargetDeviceCreateWithParameters; + // PFN_WDFUSBTARGETDEVICEQUERYUSBCAPABILITY pfnWdfUsbTargetDeviceQueryUsbCapability; + // PFN_WDFUSBTARGETDEVICECREATEURB pfnWdfUsbTargetDeviceCreateUrb; + // PFN_WDFUSBTARGETDEVICECREATEISOCHURB pfnWdfUsbTargetDeviceCreateIsochUrb; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCreateWithParameters; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceQueryUsbCapability; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCreateUrb; + PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCreateIsochUrb; + PFN_WDFDEVICEWDMASSIGNPOWERFRAMEWORKSETTINGS pfnWdfDeviceWdmAssignPowerFrameworkSettings; - PFN_WDFDMATRANSACTIONSTOPSYSTEMTRANSFER pfnWdfDmaTransactionStopSystemTransfer; - PFN_WDFCXVERIFIERKEBUGCHECK pfnWdfCxVerifierKeBugCheck; - PFN_WDFINTERRUPTREPORTACTIVE pfnWdfInterruptReportActive; - PFN_WDFINTERRUPTREPORTINACTIVE pfnWdfInterruptReportInactive; + // PFN_WDFDMATRANSACTIONSTOPSYSTEMTRANSFER pfnWdfDmaTransactionStopSystemTransfer; + // PFN_WDFCXVERIFIERKEBUGCHECK pfnWdfCxVerifierKeBugCheck; + // PFN_WDFINTERRUPTREPORTACTIVE pfnWdfInterruptReportActive; + // PFN_WDFINTERRUPTREPORTINACTIVE pfnWdfInterruptReportInactive; + PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionStopSystemTransfer; + PFN_ROSWDFUNIMPLEMENTED pfnWdfCxVerifierKeBugCheck; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptReportActive; + PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptReportInactive; + PFN_WDFDEVICEINITSETRELEASEHARDWAREORDERONFAILURE pfnWdfDeviceInitSetReleaseHardwareOrderOnFailure; - PFN_WDFGETTRIAGEINFO pfnWdfGetTriageInfo; + // PFN_WDFGETTRIAGEINFO pfnWdfGetTriageInfo; + PFN_ROSWDFUNIMPLEMENTED pfnWdfGetTriageInfo; + PFN_WDFDEVICEINITSETIOTYPEEX pfnWdfDeviceInitSetIoTypeEx; PFN_WDFDEVICEQUERYPROPERTYEX pfnWdfDeviceQueryPropertyEx; PFN_WDFDEVICEALLOCANDQUERYPROPERTYEX pfnWdfDeviceAllocAndQueryPropertyEx; @@ -478,6 +641,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfChildListCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -494,6 +658,7 @@ WDFEXPORT(WdfChildListCreate)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfChildListGetDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -505,6 +670,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfChildListRetrievePdo)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -518,6 +684,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfChildListRetrieveAddressDescription)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -532,6 +699,7 @@ WDFEXPORT(WdfChildListRetrieveAddressDescription)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfChildListBeginScan)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -542,6 +710,7 @@ WDFEXPORT(WdfChildListBeginScan)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfChildListEndScan)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -552,6 +721,7 @@ WDFEXPORT(WdfChildListEndScan)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfChildListBeginIteration)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -565,6 +735,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfChildListRetrieveNextDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -581,6 +752,7 @@ WDFEXPORT(WdfChildListRetrieveNextDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfChildListEndIteration)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -594,6 +766,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfChildListAddOrUpdateChildDescriptionAsPresent)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -609,6 +782,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfChildListUpdateChildDescriptionAsMissing)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -621,6 +795,7 @@ WDFEXPORT(WdfChildListUpdateChildDescriptionAsMissing)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfChildListUpdateAllChildDescriptionsAsPresent)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -631,6 +806,7 @@ WDFEXPORT(WdfChildListUpdateAllChildDescriptionsAsPresent)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfChildListRequestChildEject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -644,6 +820,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfCollectionCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -656,6 +833,7 @@ WDFEXPORT(WdfCollectionCreate)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONG +STDCALL WDFEXPORT(WdfCollectionGetCount)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -667,6 +845,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfCollectionAdd)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -679,6 +858,7 @@ WDFEXPORT(WdfCollectionAdd)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfCollectionRemove)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -691,6 +871,7 @@ WDFEXPORT(WdfCollectionRemove)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfCollectionRemoveItem)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -703,6 +884,7 @@ WDFEXPORT(WdfCollectionRemoveItem)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFOBJECT +STDCALL WDFEXPORT(WdfCollectionGetItem)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -715,6 +897,7 @@ WDFEXPORT(WdfCollectionGetItem)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFOBJECT +STDCALL WDFEXPORT(WdfCollectionGetFirstItem)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -725,6 +908,7 @@ WDFEXPORT(WdfCollectionGetFirstItem)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFOBJECT +STDCALL WDFEXPORT(WdfCollectionGetLastItem)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -736,6 +920,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfCommonBufferCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -754,6 +939,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfCommonBufferCreateWithConfig)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -773,6 +959,7 @@ WDFEXPORT(WdfCommonBufferCreateWithConfig)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PVOID +STDCALL WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -783,6 +970,7 @@ WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PHYSICAL_ADDRESS +STDCALL WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -793,6 +981,7 @@ WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI size_t +STDCALL WDFEXPORT(WdfCommonBufferGetLength)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -804,6 +993,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI PWDFDEVICE_INIT +STDCALL WDFEXPORT(WdfControlDeviceInitAllocate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -816,6 +1006,7 @@ WDFEXPORT(WdfControlDeviceInitAllocate)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfControlDeviceInitSetShutdownNotification)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -830,6 +1021,7 @@ WDFEXPORT(WdfControlDeviceInitSetShutdownNotification)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfControlFinishInitializing)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -841,6 +1033,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI PWDFCXDEVICE_INIT +STDCALL WDFEXPORT(WdfCxDeviceInitAllocate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -852,6 +1045,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfCxDeviceInitAssignWdmIrpPreprocessCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -871,6 +1065,7 @@ WDFEXPORT(WdfCxDeviceInitAssignWdmIrpPreprocessCallback)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfCxDeviceInitSetIoInCallerContextCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -883,6 +1078,7 @@ WDFEXPORT(WdfCxDeviceInitSetIoInCallerContextCallback)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfCxDeviceInitSetRequestAttributes)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -895,6 +1091,7 @@ WDFEXPORT(WdfCxDeviceInitSetRequestAttributes)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfCxDeviceInitSetFileObjectConfig)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -908,6 +1105,7 @@ WDFEXPORT(WdfCxDeviceInitSetFileObjectConfig)( WDFAPI VOID +STDCALL WDFEXPORT(WdfCxVerifierKeBugCheck)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -928,6 +1126,7 @@ WDFEXPORT(WdfCxVerifierKeBugCheck)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceGetDeviceState)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -940,6 +1139,7 @@ WDFEXPORT(WdfDeviceGetDeviceState)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetDeviceState)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -952,6 +1152,7 @@ WDFEXPORT(WdfDeviceSetDeviceState)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfWdmDeviceGetWdfDeviceHandle)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -962,6 +1163,7 @@ WDFEXPORT(WdfWdmDeviceGetWdfDeviceHandle)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfDeviceWdmGetDeviceObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -972,6 +1174,7 @@ WDFEXPORT(WdfDeviceWdmGetDeviceObject)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfDeviceWdmGetAttachedDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -982,6 +1185,7 @@ WDFEXPORT(WdfDeviceWdmGetAttachedDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfDeviceWdmGetPhysicalDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -993,6 +1197,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceWdmDispatchPreprocessedIrp)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1006,6 +1211,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceWdmDispatchIrp)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1021,6 +1227,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceWdmDispatchIrpToIoQueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1038,6 +1245,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAddDependentUsageDeviceObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1050,6 +1258,7 @@ WDFEXPORT(WdfDeviceAddDependentUsageDeviceObject)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceRemoveDependentUsageDeviceObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1063,6 +1272,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAddRemovalRelationsPhysicalDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1075,6 +1285,7 @@ WDFEXPORT(WdfDeviceAddRemovalRelationsPhysicalDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceRemoveRemovalRelationsPhysicalDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1087,6 +1298,7 @@ WDFEXPORT(WdfDeviceRemoveRemovalRelationsPhysicalDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceClearRemovalRelationsDevices)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1097,6 +1309,7 @@ WDFEXPORT(WdfDeviceClearRemovalRelationsDevices)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDRIVER +STDCALL WDFEXPORT(WdfDeviceGetDriver)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1108,6 +1321,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceRetrieveDeviceName)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1121,6 +1335,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAssignMofResourceName)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1133,6 +1348,7 @@ WDFEXPORT(WdfDeviceAssignMofResourceName)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFIOTARGET +STDCALL WDFEXPORT(WdfDeviceGetIoTarget)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1143,6 +1359,7 @@ WDFEXPORT(WdfDeviceGetIoTarget)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDF_DEVICE_PNP_STATE +STDCALL WDFEXPORT(WdfDeviceGetDevicePnpState)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1153,6 +1370,7 @@ WDFEXPORT(WdfDeviceGetDevicePnpState)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDF_DEVICE_POWER_STATE +STDCALL WDFEXPORT(WdfDeviceGetDevicePowerState)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1163,6 +1381,7 @@ WDFEXPORT(WdfDeviceGetDevicePowerState)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDF_DEVICE_POWER_POLICY_STATE +STDCALL WDFEXPORT(WdfDeviceGetDevicePowerPolicyState)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1174,6 +1393,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAssignS0IdleSettings)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1187,6 +1407,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAssignSxWakeSettings)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1200,6 +1421,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceOpenRegistryKey)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1219,6 +1441,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceOpenDevicemapKey)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1237,6 +1460,7 @@ WDFEXPORT(WdfDeviceOpenDevicemapKey)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetSpecialFileSupport)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1251,6 +1475,7 @@ WDFEXPORT(WdfDeviceSetSpecialFileSupport)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetCharacteristics)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1263,6 +1488,7 @@ WDFEXPORT(WdfDeviceSetCharacteristics)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONG +STDCALL WDFEXPORT(WdfDeviceGetCharacteristics)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1273,6 +1499,7 @@ WDFEXPORT(WdfDeviceGetCharacteristics)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONG +STDCALL WDFEXPORT(WdfDeviceGetAlignmentRequirement)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1283,6 +1510,7 @@ WDFEXPORT(WdfDeviceGetAlignmentRequirement)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetAlignmentRequirement)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1295,6 +1523,7 @@ WDFEXPORT(WdfDeviceSetAlignmentRequirement)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitFree)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1305,6 +1534,7 @@ WDFEXPORT(WdfDeviceInitFree)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPnpPowerEventCallbacks)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1317,6 +1547,7 @@ WDFEXPORT(WdfDeviceInitSetPnpPowerEventCallbacks)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerPolicyEventCallbacks)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1329,6 +1560,7 @@ WDFEXPORT(WdfDeviceInitSetPowerPolicyEventCallbacks)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerPolicyOwnership)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1342,6 +1574,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitRegisterPnpStateChangeCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1359,6 +1592,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitRegisterPowerStateChangeCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1376,6 +1610,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitRegisterPowerPolicyStateChangeCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1392,6 +1627,7 @@ WDFEXPORT(WdfDeviceInitRegisterPowerPolicyStateChangeCallback)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetExclusive)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1404,6 +1640,7 @@ WDFEXPORT(WdfDeviceInitSetExclusive)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetIoType)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1416,6 +1653,7 @@ WDFEXPORT(WdfDeviceInitSetIoType)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerNotPageable)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1426,6 +1664,7 @@ WDFEXPORT(WdfDeviceInitSetPowerNotPageable)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerPageable)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1436,6 +1675,7 @@ WDFEXPORT(WdfDeviceInitSetPowerPageable)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerInrush)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1446,6 +1686,7 @@ WDFEXPORT(WdfDeviceInitSetPowerInrush)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetDeviceType)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1459,6 +1700,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitAssignName)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1472,6 +1714,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitAssignSDDLString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1484,6 +1727,7 @@ WDFEXPORT(WdfDeviceInitAssignSDDLString)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetDeviceClass)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1496,6 +1740,7 @@ WDFEXPORT(WdfDeviceInitSetDeviceClass)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetCharacteristics)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1510,6 +1755,7 @@ WDFEXPORT(WdfDeviceInitSetCharacteristics)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetFileObjectConfig)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1524,6 +1770,7 @@ WDFEXPORT(WdfDeviceInitSetFileObjectConfig)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetRequestAttributes)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1537,6 +1784,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitAssignWdmIrpPreprocessCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1556,6 +1804,7 @@ WDFEXPORT(WdfDeviceInitAssignWdmIrpPreprocessCallback)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetIoInCallerContextCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1568,6 +1817,7 @@ WDFEXPORT(WdfDeviceInitSetIoInCallerContextCallback)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetRemoveLockOptions)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1581,6 +1831,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1595,6 +1846,7 @@ WDFEXPORT(WdfDeviceCreate)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetStaticStopRemove)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1608,6 +1860,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceCreateDeviceInterface)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1622,6 +1875,7 @@ WDFEXPORT(WdfDeviceCreateDeviceInterface)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetDeviceInterfaceState)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1639,6 +1893,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceRetrieveDeviceInterfaceString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1656,6 +1911,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceCreateSymbolicLink)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1669,6 +1925,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceQueryProperty)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1688,6 +1945,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAllocAndQueryProperty)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1707,6 +1965,7 @@ WDFEXPORT(WdfDeviceAllocAndQueryProperty)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetPnpCapabilities)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1719,6 +1978,7 @@ WDFEXPORT(WdfDeviceSetPnpCapabilities)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetPowerCapabilities)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1731,6 +1991,7 @@ WDFEXPORT(WdfDeviceSetPowerCapabilities)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetBusInformationForChildren)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1744,6 +2005,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceIndicateWakeStatus)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1756,6 +2018,7 @@ WDFEXPORT(WdfDeviceIndicateWakeStatus)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceSetFailed)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1770,6 +2033,7 @@ _When_(WaitForD0 == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(WaitForD0 != 0, _IRQL_requires_max_(PASSIVE_LEVEL)) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceStopIdleNoTrack)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1782,6 +2046,7 @@ WDFEXPORT(WdfDeviceStopIdleNoTrack)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceResumeIdleNoTrack)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1794,6 +2059,7 @@ _When_(WaitForD0 == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(WaitForD0 != 0, _IRQL_requires_max_(PASSIVE_LEVEL)) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceStopIdleActual)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1812,6 +2078,7 @@ WDFEXPORT(WdfDeviceStopIdleActual)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceResumeIdleActual)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1828,6 +2095,7 @@ WDFEXPORT(WdfDeviceResumeIdleActual)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFFILEOBJECT +STDCALL WDFEXPORT(WdfDeviceGetFileObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1841,6 +2109,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceEnqueueRequest)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1853,6 +2122,7 @@ WDFEXPORT(WdfDeviceEnqueueRequest)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFQUEUE +STDCALL WDFEXPORT(WdfDeviceGetDefaultQueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1864,6 +2134,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceConfigureRequestDispatching)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1880,6 +2151,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceConfigureWdmIrpDispatchCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1898,6 +2170,7 @@ WDFEXPORT(WdfDeviceConfigureWdmIrpDispatchCallback)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI POWER_ACTION +STDCALL WDFEXPORT(WdfDeviceGetSystemPowerAction)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1909,6 +2182,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceWdmAssignPowerFrameworkSettings)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1921,6 +2195,7 @@ WDFEXPORT(WdfDeviceWdmAssignPowerFrameworkSettings)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetReleaseHardwareOrderOnFailure)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1933,6 +2208,7 @@ WDFEXPORT(WdfDeviceInitSetReleaseHardwareOrderOnFailure)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetIoTypeEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1946,6 +2222,7 @@ _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceQueryPropertyEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1967,6 +2244,7 @@ _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAllocAndQueryPropertyEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1989,6 +2267,7 @@ _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAssignProperty)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2007,6 +2286,7 @@ WDFEXPORT(WdfDeviceAssignProperty)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFIOTARGET +STDCALL WDFEXPORT(WdfDeviceGetSelfIoTarget)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2017,6 +2297,7 @@ WDFEXPORT(WdfDeviceGetSelfIoTarget)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitAllowSelfIoTarget)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2028,6 +2309,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaEnablerCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2045,6 +2327,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaEnablerConfigureSystemProfile)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2059,6 +2342,7 @@ WDFEXPORT(WdfDmaEnablerConfigureSystemProfile)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI size_t +STDCALL WDFEXPORT(WdfDmaEnablerGetMaximumLength)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2069,6 +2353,7 @@ WDFEXPORT(WdfDmaEnablerGetMaximumLength)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI size_t +STDCALL WDFEXPORT(WdfDmaEnablerGetMaximumScatterGatherElements)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2079,6 +2364,7 @@ WDFEXPORT(WdfDmaEnablerGetMaximumScatterGatherElements)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaEnablerSetMaximumScatterGatherElements)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2092,6 +2378,7 @@ WDFEXPORT(WdfDmaEnablerSetMaximumScatterGatherElements)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI size_t +STDCALL WDFEXPORT(WdfDmaEnablerGetFragmentLength)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2104,6 +2391,7 @@ WDFEXPORT(WdfDmaEnablerGetFragmentLength)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PDMA_ADAPTER +STDCALL WDFEXPORT(WdfDmaEnablerWdmGetDmaAdapter)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2117,6 +2405,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaTransactionCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2132,6 +2421,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaTransactionInitialize)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2154,6 +2444,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaTransactionInitializeUsingOffset)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2176,6 +2467,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaTransactionInitializeUsingRequest)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2193,6 +2485,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaTransactionExecute)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2206,6 +2499,7 @@ _Success_(TRUE) _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaTransactionRelease)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2216,6 +2510,7 @@ WDFEXPORT(WdfDmaTransactionRelease)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfDmaTransactionDmaCompleted)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2228,6 +2523,7 @@ WDFEXPORT(WdfDmaTransactionDmaCompleted)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfDmaTransactionDmaCompletedWithLength)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2242,6 +2538,7 @@ WDFEXPORT(WdfDmaTransactionDmaCompletedWithLength)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfDmaTransactionDmaCompletedFinal)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2256,6 +2553,7 @@ WDFEXPORT(WdfDmaTransactionDmaCompletedFinal)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI size_t +STDCALL WDFEXPORT(WdfDmaTransactionGetBytesTransferred)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2266,6 +2564,7 @@ WDFEXPORT(WdfDmaTransactionGetBytesTransferred)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaTransactionSetMaximumLength)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2278,6 +2577,7 @@ WDFEXPORT(WdfDmaTransactionSetMaximumLength)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFREQUEST +STDCALL WDFEXPORT(WdfDmaTransactionGetRequest)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2288,6 +2588,7 @@ WDFEXPORT(WdfDmaTransactionGetRequest)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI size_t +STDCALL WDFEXPORT(WdfDmaTransactionGetCurrentDmaTransferLength)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2298,6 +2599,7 @@ WDFEXPORT(WdfDmaTransactionGetCurrentDmaTransferLength)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfDmaTransactionGetDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2308,6 +2610,7 @@ WDFEXPORT(WdfDmaTransactionGetDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaTransactionGetTransferInfo)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2322,6 +2625,7 @@ WDFEXPORT(WdfDmaTransactionGetTransferInfo)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaTransactionSetChannelConfigurationCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2336,6 +2640,7 @@ WDFEXPORT(WdfDmaTransactionSetChannelConfigurationCallback)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaTransactionSetTransferCompleteCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2350,6 +2655,7 @@ WDFEXPORT(WdfDmaTransactionSetTransferCompleteCallback)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaTransactionSetImmediateExecution)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2362,6 +2668,7 @@ WDFEXPORT(WdfDmaTransactionSetImmediateExecution)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDmaTransactionAllocateResources)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2380,6 +2687,7 @@ WDFEXPORT(WdfDmaTransactionAllocateResources)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaTransactionSetDeviceAddressOffset)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2392,6 +2700,7 @@ WDFEXPORT(WdfDmaTransactionSetDeviceAddressOffset)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaTransactionFreeResources)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2402,6 +2711,7 @@ WDFEXPORT(WdfDmaTransactionFreeResources)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfDmaTransactionCancel)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2412,6 +2722,7 @@ WDFEXPORT(WdfDmaTransactionCancel)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PVOID +STDCALL WDFEXPORT(WdfDmaTransactionWdmGetTransferContext)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2422,6 +2733,7 @@ WDFEXPORT(WdfDmaTransactionWdmGetTransferContext)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDmaTransactionStopSystemTransfer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2433,6 +2745,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDpcCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2447,6 +2760,7 @@ WDFEXPORT(WdfDpcCreate)( _IRQL_requires_max_(HIGH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfDpcEnqueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2458,6 +2772,7 @@ _When_(Wait == __true, _IRQL_requires_max_(PASSIVE_LEVEL)) _When_(Wait == __false, _IRQL_requires_max_(HIGH_LEVEL)) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfDpcCancel)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2470,6 +2785,7 @@ WDFEXPORT(WdfDpcCancel)( _IRQL_requires_max_(HIGH_LEVEL) WDFAPI WDFOBJECT +STDCALL WDFEXPORT(WdfDpcGetParentObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2480,6 +2796,7 @@ WDFEXPORT(WdfDpcGetParentObject)( _IRQL_requires_max_(HIGH_LEVEL) WDFAPI PKDPC +STDCALL WDFEXPORT(WdfDpcWdmGetDpc)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2491,6 +2808,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDriverCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2509,6 +2827,7 @@ WDFEXPORT(WdfDriverCreate)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI PWSTR +STDCALL WDFEXPORT(WdfDriverGetRegistryPath)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2519,6 +2838,7 @@ WDFEXPORT(WdfDriverGetRegistryPath)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PDRIVER_OBJECT +STDCALL WDFEXPORT(WdfDriverWdmGetDriverObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2530,6 +2850,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDriverOpenParametersRegistryKey)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2546,6 +2867,7 @@ WDFEXPORT(WdfDriverOpenParametersRegistryKey)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDRIVER +STDCALL WDFEXPORT(WdfWdmDriverGetWdfDriverHandle)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2557,6 +2879,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDriverRegisterTraceInfo)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2572,6 +2895,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDriverRetrieveVersionString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2585,6 +2909,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfDriverIsVersionAvailable)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2597,6 +2922,7 @@ WDFEXPORT(WdfDriverIsVersionAvailable)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfFdoInitWdmGetPhysicalDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2608,6 +2934,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitOpenRegistryKey)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2627,6 +2954,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitQueryProperty)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2646,6 +2974,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitAllocAndQueryProperty)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2666,6 +2995,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitQueryPropertyEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2687,6 +3017,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitAllocAndQueryPropertyEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2708,6 +3039,7 @@ WDFEXPORT(WdfFdoInitAllocAndQueryPropertyEx)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfFdoInitSetEventCallbacks)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2720,6 +3052,7 @@ WDFEXPORT(WdfFdoInitSetEventCallbacks)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfFdoInitSetFilter)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2730,6 +3063,7 @@ WDFEXPORT(WdfFdoInitSetFilter)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfFdoInitSetDefaultChildListConfig)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2745,6 +3079,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoQueryForInterface)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2765,6 +3100,7 @@ WDFEXPORT(WdfFdoQueryForInterface)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFCHILDLIST +STDCALL WDFEXPORT(WdfFdoGetDefaultChildList)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2776,6 +3112,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoAddStaticChild)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2788,6 +3125,7 @@ WDFEXPORT(WdfFdoAddStaticChild)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfFdoLockStaticChildListForIteration)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2799,6 +3137,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfFdoRetrieveNextStaticChild)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2813,6 +3152,7 @@ WDFEXPORT(WdfFdoRetrieveNextStaticChild)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfFdoUnlockStaticChildListFromIteration)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2823,6 +3163,7 @@ WDFEXPORT(WdfFdoUnlockStaticChildListFromIteration)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI PUNICODE_STRING +STDCALL WDFEXPORT(WdfFileObjectGetFileName)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2833,6 +3174,7 @@ WDFEXPORT(WdfFileObjectGetFileName)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONG +STDCALL WDFEXPORT(WdfFileObjectGetFlags)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2843,6 +3185,7 @@ WDFEXPORT(WdfFileObjectGetFlags)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfFileObjectGetDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2853,6 +3196,7 @@ WDFEXPORT(WdfFileObjectGetDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PFILE_OBJECT +STDCALL WDFEXPORT(WdfFileObjectWdmGetFileObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2864,6 +3208,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfInterruptCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2879,6 +3224,7 @@ WDFEXPORT(WdfInterruptCreate)( WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfInterruptQueueDpcForIsr)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2888,6 +3234,7 @@ WDFEXPORT(WdfInterruptQueueDpcForIsr)( WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfInterruptQueueWorkItemForIsr)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2898,6 +3245,7 @@ WDFEXPORT(WdfInterruptQueueWorkItemForIsr)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfInterruptSynchronize)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2912,6 +3260,7 @@ WDFEXPORT(WdfInterruptSynchronize)( _IRQL_requires_max_(DISPATCH_LEVEL + 1) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptAcquireLock)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2924,6 +3273,7 @@ WDFEXPORT(WdfInterruptAcquireLock)( _IRQL_requires_max_(DISPATCH_LEVEL + 1) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptReleaseLock)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2936,6 +3286,7 @@ WDFEXPORT(WdfInterruptReleaseLock)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptEnable)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2946,6 +3297,7 @@ WDFEXPORT(WdfInterruptEnable)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptDisable)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2956,6 +3308,7 @@ WDFEXPORT(WdfInterruptDisable)( _Must_inspect_result_ WDFAPI PKINTERRUPT +STDCALL WDFEXPORT(WdfInterruptWdmGetInterrupt)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2966,6 +3319,7 @@ WDFEXPORT(WdfInterruptWdmGetInterrupt)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptGetInfo)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2978,6 +3332,7 @@ WDFEXPORT(WdfInterruptGetInfo)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptSetPolicy)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2994,6 +3349,7 @@ WDFEXPORT(WdfInterruptSetPolicy)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptSetExtendedPolicy)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3005,6 +3361,7 @@ WDFEXPORT(WdfInterruptSetExtendedPolicy)( WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfInterruptGetDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3017,6 +3374,7 @@ _Post_satisfies_(return == 1 || return == 0) _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfInterruptTryToAcquireLock)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3029,6 +3387,7 @@ WDFEXPORT(WdfInterruptTryToAcquireLock)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptReportActive)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3039,6 +3398,7 @@ WDFEXPORT(WdfInterruptReportActive)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfInterruptReportInactive)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3050,6 +3410,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3066,6 +3427,7 @@ WDFEXPORT(WdfIoQueueCreate)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDF_IO_QUEUE_STATE +STDCALL WDFEXPORT(WdfIoQueueGetState)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3080,6 +3442,7 @@ WDFEXPORT(WdfIoQueueGetState)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueueStart)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3090,6 +3453,7 @@ WDFEXPORT(WdfIoQueueStart)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueueStop)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3106,6 +3470,7 @@ WDFEXPORT(WdfIoQueueStop)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueueStopSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3116,6 +3481,7 @@ WDFEXPORT(WdfIoQueueStopSynchronously)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfIoQueueGetDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3127,6 +3493,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueRetrieveNextRequest)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3140,6 +3507,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueRetrieveRequestByFileObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3155,6 +3523,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueFindRequest)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3174,6 +3543,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueRetrieveFoundRequest)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3188,6 +3558,7 @@ WDFEXPORT(WdfIoQueueRetrieveFoundRequest)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueueDrainSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3198,6 +3569,7 @@ WDFEXPORT(WdfIoQueueDrainSynchronously)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueueDrain)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3214,6 +3586,7 @@ WDFEXPORT(WdfIoQueueDrain)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueuePurgeSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3224,6 +3597,7 @@ WDFEXPORT(WdfIoQueuePurgeSynchronously)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueuePurge)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3241,6 +3615,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueReadyNotify)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3256,6 +3631,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueAssignForwardProgressPolicy)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3268,6 +3644,7 @@ WDFEXPORT(WdfIoQueueAssignForwardProgressPolicy)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueueStopAndPurge)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3284,6 +3661,7 @@ WDFEXPORT(WdfIoQueueStopAndPurge)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoQueueStopAndPurgeSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3295,6 +3673,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3310,6 +3689,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetOpen)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3322,6 +3702,7 @@ WDFEXPORT(WdfIoTargetOpen)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoTargetCloseForQueryRemove)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3332,6 +3713,7 @@ WDFEXPORT(WdfIoTargetCloseForQueryRemove)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoTargetClose)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3343,6 +3725,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetStart)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3354,6 +3737,7 @@ _When_(Action == 3, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(Action == 0 || Action == 1 || Action == 2, _IRQL_requires_max_(PASSIVE_LEVEL)) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoTargetStop)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3368,6 +3752,7 @@ _When_(Action == 2, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(Action == 0 || Action == 1, _IRQL_requires_max_(PASSIVE_LEVEL)) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoTargetPurge)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3381,6 +3766,7 @@ WDFEXPORT(WdfIoTargetPurge)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDF_IO_TARGET_STATE +STDCALL WDFEXPORT(WdfIoTargetGetState)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3391,6 +3777,7 @@ WDFEXPORT(WdfIoTargetGetState)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfIoTargetGetDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3402,6 +3789,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetQueryTargetProperty)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3422,6 +3810,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetAllocAndQueryTargetProperty)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3442,6 +3831,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetQueryForInterface)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3462,6 +3852,7 @@ WDFEXPORT(WdfIoTargetQueryForInterface)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfIoTargetWdmGetTargetDeviceObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3472,6 +3863,7 @@ WDFEXPORT(WdfIoTargetWdmGetTargetDeviceObject)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfIoTargetWdmGetTargetPhysicalDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3482,6 +3874,7 @@ WDFEXPORT(WdfIoTargetWdmGetTargetPhysicalDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PFILE_OBJECT +STDCALL WDFEXPORT(WdfIoTargetWdmGetTargetFileObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3492,6 +3885,7 @@ WDFEXPORT(WdfIoTargetWdmGetTargetFileObject)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI HANDLE +STDCALL WDFEXPORT(WdfIoTargetWdmGetTargetFileHandle)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3503,6 +3897,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendReadSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3524,6 +3919,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForRead)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3543,6 +3939,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendWriteSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3564,6 +3961,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForWrite)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3583,6 +3981,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendIoctlSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3606,6 +4005,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForIoctl)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3629,6 +4029,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendInternalIoctlSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3652,6 +4053,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctl)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3675,6 +4077,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendInternalIoctlOthersSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3700,6 +4103,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctlOthers)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3726,6 +4130,7 @@ WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctlOthers)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSelfAssignDefaultIoQueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3740,6 +4145,7 @@ _When_(PoolType == 1 || PoolType == 257, _IRQL_requires_max_(APC_LEVEL)) _When_(PoolType == 0 || PoolType == 256, _IRQL_requires_max_(DISPATCH_LEVEL)) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3763,6 +4169,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryCreatePreallocated)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3780,6 +4187,7 @@ WDFEXPORT(WdfMemoryCreatePreallocated)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PVOID +STDCALL WDFEXPORT(WdfMemoryGetBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3793,6 +4201,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryAssignBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3809,6 +4218,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryCopyToBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3827,6 +4237,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryCopyFromBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3846,6 +4257,7 @@ _When_(PoolType == 1 || PoolType == 257, _IRQL_requires_max_(APC_LEVEL)) _When_(PoolType == 0 || PoolType == 256, _IRQL_requires_max_(DISPATCH_LEVEL)) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfLookasideListCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3869,6 +4281,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryCreateFromLookaside)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3882,6 +4295,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceMiniportCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3901,6 +4315,7 @@ WDFEXPORT(WdfDeviceMiniportCreate)( WDFAPI VOID +STDCALL WDFEXPORT(WdfDriverMiniportUnload)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3922,6 +4337,7 @@ WDFEXPORT(WdfObjectGetTypedContextWorker)( WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfObjectAllocateContext)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3945,6 +4361,7 @@ WDFEXPORT(WdfObjectContextGetObject)( WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectReferenceActual)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3960,6 +4377,7 @@ WDFEXPORT(WdfObjectReferenceActual)( WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectDereferenceActual)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3977,6 +4395,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfObjectCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3989,6 +4408,7 @@ WDFEXPORT(WdfObjectCreate)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectDelete)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4000,6 +4420,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfObjectQuery)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4017,6 +4438,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI PWDFDEVICE_INIT +STDCALL WDFEXPORT(WdfPdoInitAllocate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4027,6 +4449,7 @@ WDFEXPORT(WdfPdoInitAllocate)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfPdoInitSetEventCallbacks)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4040,6 +4463,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAssignDeviceID)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4053,6 +4477,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAssignInstanceID)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4066,6 +4491,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAddHardwareID)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4079,6 +4505,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAddCompatibleID)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4092,6 +4519,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAssignContainerID)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4105,6 +4533,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAddDeviceText)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4121,6 +4550,7 @@ WDFEXPORT(WdfPdoInitAddDeviceText)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfPdoInitSetDefaultLocale)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4134,6 +4564,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAssignRawDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4146,6 +4577,7 @@ WDFEXPORT(WdfPdoInitAssignRawDevice)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfPdoInitAllowForwardingRequestToParent)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4157,6 +4589,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoMarkMissing)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4167,6 +4600,7 @@ WDFEXPORT(WdfPdoMarkMissing)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfPdoRequestEject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4177,6 +4611,7 @@ WDFEXPORT(WdfPdoRequestEject)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfPdoGetParent)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4188,6 +4623,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoRetrieveIdentificationDescription)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4201,6 +4637,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoRetrieveAddressDescription)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4214,6 +4651,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoUpdateAddressDescription)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4227,6 +4665,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoAddEjectionRelationsPhysicalDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4239,6 +4678,7 @@ WDFEXPORT(WdfPdoAddEjectionRelationsPhysicalDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfPdoRemoveEjectionRelationsPhysicalDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4251,6 +4691,7 @@ WDFEXPORT(WdfPdoRemoveEjectionRelationsPhysicalDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfPdoClearEjectionRelationsDevices)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4262,6 +4703,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAddQueryInterface)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4275,6 +4717,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryOpenKey)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4294,6 +4737,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryCreateKey)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4316,6 +4760,7 @@ WDFEXPORT(WdfRegistryCreateKey)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRegistryClose)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4326,6 +4771,7 @@ WDFEXPORT(WdfRegistryClose)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI HANDLE +STDCALL WDFEXPORT(WdfRegistryWdmGetHandle)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4337,6 +4783,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryRemoveKey)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4348,6 +4795,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryRemoveValue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4361,6 +4809,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryValue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4382,6 +4831,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryMemory)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4404,6 +4854,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryMultiString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4421,6 +4872,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryUnicodeString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4438,6 +4890,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4453,6 +4906,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryULong)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4468,6 +4922,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignValue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4487,6 +4942,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignMemory)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4506,6 +4962,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignMultiString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4521,6 +4978,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignUnicodeString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4536,6 +4994,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4551,6 +5010,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignULong)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4566,6 +5026,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4581,6 +5042,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestCreateFromIrp)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4597,6 +5059,7 @@ WDFEXPORT(WdfRequestCreateFromIrp)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestReuse)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4610,6 +5073,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestChangeTarget)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4622,6 +5086,7 @@ WDFEXPORT(WdfRequestChangeTarget)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestFormatRequestUsingCurrentType)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4632,6 +5097,7 @@ WDFEXPORT(WdfRequestFormatRequestUsingCurrentType)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestWdmFormatUsingStackLocation)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4645,6 +5111,7 @@ _IRQL_requires_max_(DISPATCH_LEVEL) _When_(Options->Flags & WDF_REQUEST_SEND_OPTION_SYNCHRONOUS == 0, _Must_inspect_result_) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfRequestSend)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4660,6 +5127,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestGetStatus)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4670,6 +5138,7 @@ WDFEXPORT(WdfRequestGetStatus)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestMarkCancelable)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4683,6 +5152,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestMarkCancelableEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4696,6 +5166,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestUnmarkCancelable)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4707,6 +5178,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfRequestIsCanceled)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4717,6 +5189,7 @@ WDFEXPORT(WdfRequestIsCanceled)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfRequestCancelSentRequest)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4728,6 +5201,7 @@ _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfRequestIsFrom32BitProcess)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4738,6 +5212,7 @@ WDFEXPORT(WdfRequestIsFrom32BitProcess)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestSetCompletionRoutine)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4752,6 +5227,7 @@ WDFEXPORT(WdfRequestSetCompletionRoutine)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestGetCompletionParams)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4765,6 +5241,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestAllocateTimer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4775,6 +5252,7 @@ WDFEXPORT(WdfRequestAllocateTimer)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestComplete)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4787,6 +5265,7 @@ WDFEXPORT(WdfRequestComplete)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestCompleteWithPriorityBoost)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4801,6 +5280,7 @@ WDFEXPORT(WdfRequestCompleteWithPriorityBoost)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestCompleteWithInformation)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4815,6 +5295,7 @@ WDFEXPORT(WdfRequestCompleteWithInformation)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestGetParameters)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4828,6 +5309,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRetrieveInputMemory)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4841,6 +5323,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRetrieveOutputMemory)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4854,6 +5337,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRetrieveInputBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4871,6 +5355,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRetrieveOutputBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4888,6 +5373,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRetrieveInputWdmMdl)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4901,6 +5387,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRetrieveOutputWdmMdl)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4914,6 +5401,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRetrieveUnsafeUserInputBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4931,6 +5419,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRetrieveUnsafeUserOutputBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4947,6 +5436,7 @@ WDFEXPORT(WdfRequestRetrieveUnsafeUserOutputBuffer)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestSetInformation)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4959,6 +5449,7 @@ WDFEXPORT(WdfRequestSetInformation)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONG_PTR +STDCALL WDFEXPORT(WdfRequestGetInformation)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4969,6 +5460,7 @@ WDFEXPORT(WdfRequestGetInformation)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFFILEOBJECT +STDCALL WDFEXPORT(WdfRequestGetFileObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4980,6 +5472,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestProbeAndLockUserBufferForRead)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -4997,6 +5490,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestProbeAndLockUserBufferForWrite)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5013,6 +5507,7 @@ WDFEXPORT(WdfRequestProbeAndLockUserBufferForWrite)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI KPROCESSOR_MODE +STDCALL WDFEXPORT(WdfRequestGetRequestorMode)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5024,6 +5519,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestForwardToIoQueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5036,6 +5532,7 @@ WDFEXPORT(WdfRequestForwardToIoQueue)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFQUEUE +STDCALL WDFEXPORT(WdfRequestGetIoQueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5047,6 +5544,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestRequeue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5057,6 +5555,7 @@ WDFEXPORT(WdfRequestRequeue)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfRequestStopAcknowledge)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5069,6 +5568,7 @@ WDFEXPORT(WdfRequestStopAcknowledge)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PIRP +STDCALL WDFEXPORT(WdfRequestWdmGetIrp)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5079,6 +5579,7 @@ WDFEXPORT(WdfRequestWdmGetIrp)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfRequestIsReserved)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5090,6 +5591,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfRequestForwardToParentDeviceIoQueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5104,6 +5606,7 @@ WDFEXPORT(WdfRequestForwardToParentDeviceIoQueue)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoResourceRequirementsListSetSlotNumber)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5116,6 +5619,7 @@ WDFEXPORT(WdfIoResourceRequirementsListSetSlotNumber)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoResourceRequirementsListSetInterfaceType)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5130,6 +5634,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoResourceRequirementsListAppendIoResList)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5143,6 +5648,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoResourceRequirementsListInsertIoResList)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5157,6 +5663,7 @@ WDFEXPORT(WdfIoResourceRequirementsListInsertIoResList)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONG +STDCALL WDFEXPORT(WdfIoResourceRequirementsListGetCount)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5167,6 +5674,7 @@ WDFEXPORT(WdfIoResourceRequirementsListGetCount)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFIORESLIST +STDCALL WDFEXPORT(WdfIoResourceRequirementsListGetIoResList)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5179,6 +5687,7 @@ WDFEXPORT(WdfIoResourceRequirementsListGetIoResList)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoResourceRequirementsListRemove)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5191,6 +5700,7 @@ WDFEXPORT(WdfIoResourceRequirementsListRemove)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoResourceRequirementsListRemoveByIoResList)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5204,6 +5714,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoResourceListCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5219,6 +5730,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoResourceListAppendDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5232,6 +5744,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoResourceListInsertDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5246,6 +5759,7 @@ WDFEXPORT(WdfIoResourceListInsertDescriptor)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoResourceListUpdateDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5260,6 +5774,7 @@ WDFEXPORT(WdfIoResourceListUpdateDescriptor)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONG +STDCALL WDFEXPORT(WdfIoResourceListGetCount)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5270,6 +5785,7 @@ WDFEXPORT(WdfIoResourceListGetCount)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PIO_RESOURCE_DESCRIPTOR +STDCALL WDFEXPORT(WdfIoResourceListGetDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5282,6 +5798,7 @@ WDFEXPORT(WdfIoResourceListGetDescriptor)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoResourceListRemove)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5294,6 +5811,7 @@ WDFEXPORT(WdfIoResourceListRemove)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfIoResourceListRemoveByDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5307,6 +5825,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfCmResourceListAppendDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5320,6 +5839,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfCmResourceListInsertDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5334,6 +5854,7 @@ WDFEXPORT(WdfCmResourceListInsertDescriptor)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONG +STDCALL WDFEXPORT(WdfCmResourceListGetCount)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5344,6 +5865,7 @@ WDFEXPORT(WdfCmResourceListGetCount)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI PCM_PARTIAL_RESOURCE_DESCRIPTOR +STDCALL WDFEXPORT(WdfCmResourceListGetDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5356,6 +5878,7 @@ WDFEXPORT(WdfCmResourceListGetDescriptor)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfCmResourceListRemove)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5368,6 +5891,7 @@ WDFEXPORT(WdfCmResourceListRemove)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfCmResourceListRemoveByDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5381,6 +5905,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfStringCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5395,6 +5920,7 @@ WDFEXPORT(WdfStringCreate)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfStringGetUnicodeString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5407,6 +5933,7 @@ WDFEXPORT(WdfStringGetUnicodeString)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectAcquireLock)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5419,6 +5946,7 @@ WDFEXPORT(WdfObjectAcquireLock)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectReleaseLock)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5432,6 +5960,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfWaitLockCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5449,6 +5978,7 @@ _When_(Timeout != NULL && return == STATUS_SUCCESS, _Acquires_lock_(Lock)) _When_(Timeout != NULL, _Must_inspect_result_) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfWaitLockAcquire)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5462,6 +5992,7 @@ WDFEXPORT(WdfWaitLockAcquire)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfWaitLockRelease)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5475,6 +6006,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfSpinLockCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5488,6 +6020,7 @@ _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_raises_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfSpinLockAcquire)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5502,6 +6035,7 @@ _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfSpinLockRelease)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5516,6 +6050,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfTimerCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5530,6 +6065,7 @@ WDFEXPORT(WdfTimerCreate)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfTimerStart)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5543,6 +6079,7 @@ _When_(Wait == __true, _IRQL_requires_max_(PASSIVE_LEVEL)) _When_(Wait == __false, _IRQL_requires_max_(DISPATCH_LEVEL)) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfTimerStop)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5555,6 +6092,7 @@ WDFEXPORT(WdfTimerStop)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFOBJECT +STDCALL WDFEXPORT(WdfTimerGetParentObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5566,6 +6104,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5581,6 +6120,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceCreateWithParameters)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5598,6 +6138,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceRetrieveInformation)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5610,6 +6151,7 @@ WDFEXPORT(WdfUsbTargetDeviceRetrieveInformation)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfUsbTargetDeviceGetDeviceDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5623,6 +6165,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceRetrieveConfigDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5638,6 +6181,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceQueryString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5661,6 +6205,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceAllocAndQueryString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5682,6 +6227,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceFormatRequestForString)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5702,6 +6248,7 @@ WDFEXPORT(WdfUsbTargetDeviceFormatRequestForString)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI UCHAR +STDCALL WDFEXPORT(WdfUsbTargetDeviceGetNumInterfaces)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5713,6 +6260,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceSelectConfig)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5727,6 +6275,7 @@ WDFEXPORT(WdfUsbTargetDeviceSelectConfig)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI USBD_CONFIGURATION_HANDLE +STDCALL WDFEXPORT(WdfUsbTargetDeviceWdmGetConfigurationHandle)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5738,6 +6287,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceRetrieveCurrentFrameNumber)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5751,6 +6301,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceSendControlTransferSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5772,6 +6323,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceFormatRequestForControlTransfer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5791,6 +6343,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceIsConnectedSynchronous)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5802,6 +6355,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceResetPortSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5813,6 +6367,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceCyclePortSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5824,6 +6379,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceFormatRequestForCyclePort)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5837,6 +6393,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceSendUrbSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5854,6 +6411,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceFormatRequestForUrb)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5871,6 +6429,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceQueryUsbCapability)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5893,6 +6452,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceCreateUrb)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5910,6 +6470,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetDeviceCreateIsochUrb)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5928,6 +6489,7 @@ WDFEXPORT(WdfUsbTargetDeviceCreateIsochUrb)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfUsbTargetPipeGetInformation)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5940,6 +6502,7 @@ WDFEXPORT(WdfUsbTargetPipeGetInformation)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfUsbTargetPipeIsInEndpoint)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5950,6 +6513,7 @@ WDFEXPORT(WdfUsbTargetPipeIsInEndpoint)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfUsbTargetPipeIsOutEndpoint)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5960,6 +6524,7 @@ WDFEXPORT(WdfUsbTargetPipeIsOutEndpoint)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDF_USB_PIPE_TYPE +STDCALL WDFEXPORT(WdfUsbTargetPipeGetType)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5970,6 +6535,7 @@ WDFEXPORT(WdfUsbTargetPipeGetType)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfUsbTargetPipeSetNoMaximumPacketSizeCheck)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -5981,6 +6547,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeWriteSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6000,6 +6567,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeFormatRequestForWrite)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6017,6 +6585,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeReadSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6036,6 +6605,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeFormatRequestForRead)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6053,6 +6623,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeConfigContinuousReader)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6066,6 +6637,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeAbortSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6081,6 +6653,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeFormatRequestForAbort)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6094,6 +6667,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeResetSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6109,6 +6683,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeFormatRequestForReset)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6122,6 +6697,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeSendUrbSynchronously)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6139,6 +6715,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbTargetPipeFormatRequestForUrb)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6155,6 +6732,7 @@ WDFEXPORT(WdfUsbTargetPipeFormatRequestForUrb)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BYTE +STDCALL WDFEXPORT(WdfUsbInterfaceGetInterfaceNumber)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6165,6 +6743,7 @@ WDFEXPORT(WdfUsbInterfaceGetInterfaceNumber)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BYTE +STDCALL WDFEXPORT(WdfUsbInterfaceGetNumEndpoints)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6177,6 +6756,7 @@ WDFEXPORT(WdfUsbInterfaceGetNumEndpoints)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfUsbInterfaceGetDescriptor)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6191,6 +6771,7 @@ WDFEXPORT(WdfUsbInterfaceGetDescriptor)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BYTE +STDCALL WDFEXPORT(WdfUsbInterfaceGetNumSettings)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6202,6 +6783,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfUsbInterfaceSelectSetting)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6216,6 +6798,7 @@ WDFEXPORT(WdfUsbInterfaceSelectSetting)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfUsbInterfaceGetEndpointInformation)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6232,6 +6815,7 @@ WDFEXPORT(WdfUsbInterfaceGetEndpointInformation)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFUSBINTERFACE +STDCALL WDFEXPORT(WdfUsbTargetDeviceGetInterface)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6244,6 +6828,7 @@ WDFEXPORT(WdfUsbTargetDeviceGetInterface)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BYTE +STDCALL WDFEXPORT(WdfUsbInterfaceGetConfiguredSettingIndex)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6254,6 +6839,7 @@ WDFEXPORT(WdfUsbInterfaceGetConfiguredSettingIndex)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BYTE +STDCALL WDFEXPORT(WdfUsbInterfaceGetNumConfiguredPipes)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6264,6 +6850,7 @@ WDFEXPORT(WdfUsbInterfaceGetNumConfiguredPipes)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFUSBPIPE +STDCALL WDFEXPORT(WdfUsbInterfaceGetConfiguredPipe)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6278,6 +6865,7 @@ WDFEXPORT(WdfUsbInterfaceGetConfiguredPipe)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI USBD_PIPE_HANDLE +STDCALL WDFEXPORT(WdfUsbTargetPipeWdmGetPipeHandle)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6287,6 +6875,7 @@ WDFEXPORT(WdfUsbTargetPipeWdmGetPipeHandle)( WDFAPI VOID +STDCALL WDFEXPORT(WdfVerifierDbgBreakPoint)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals @@ -6294,6 +6883,7 @@ WDFEXPORT(WdfVerifierDbgBreakPoint)( WDFAPI VOID +STDCALL WDFEXPORT(WdfVerifierKeBugCheck)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6311,6 +6901,7 @@ WDFEXPORT(WdfVerifierKeBugCheck)( WDFAPI PVOID +STDCALL WDFEXPORT(WdfGetTriageInfo)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals @@ -6320,6 +6911,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfWmiProviderCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6336,6 +6928,7 @@ WDFEXPORT(WdfWmiProviderCreate)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfWmiProviderGetDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6346,6 +6939,7 @@ WDFEXPORT(WdfWmiProviderGetDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI BOOLEAN +STDCALL WDFEXPORT(WdfWmiProviderIsEnabled)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6358,6 +6952,7 @@ WDFEXPORT(WdfWmiProviderIsEnabled)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI ULONGLONG +STDCALL WDFEXPORT(WdfWmiProviderGetTracingHandle)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6369,6 +6964,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfWmiInstanceCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6386,6 +6982,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfWmiInstanceRegister)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6396,6 +6993,7 @@ WDFEXPORT(WdfWmiInstanceRegister)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfWmiInstanceDeregister)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6406,6 +7004,7 @@ WDFEXPORT(WdfWmiInstanceDeregister)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFDEVICE +STDCALL WDFEXPORT(WdfWmiInstanceGetDevice)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6416,6 +7015,7 @@ WDFEXPORT(WdfWmiInstanceGetDevice)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFWMIPROVIDER +STDCALL WDFEXPORT(WdfWmiInstanceGetProvider)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6427,6 +7027,7 @@ _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfWmiInstanceFireEvent)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6442,6 +7043,7 @@ _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfWorkItemCreate)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6456,6 +7058,7 @@ WDFEXPORT(WdfWorkItemCreate)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfWorkItemEnqueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6466,6 +7069,7 @@ WDFEXPORT(WdfWorkItemEnqueue)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFAPI WDFOBJECT +STDCALL WDFEXPORT(WdfWorkItemGetParentObject)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6476,6 +7080,7 @@ WDFEXPORT(WdfWorkItemGetParentObject)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfWorkItemFlush)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -6511,10 +7116,15 @@ WDFVERSION WdfVersion = { WDFEXPORT(WdfCollectionGetItem), WDFEXPORT(WdfCollectionGetFirstItem), WDFEXPORT(WdfCollectionGetLastItem), - WDFEXPORT(WdfCommonBufferCreate), - WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress), - WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress), - WDFEXPORT(WdfCommonBufferGetLength), + // WDFEXPORT(WdfCommonBufferCreate), + // WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress), + // WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress), + // WDFEXPORT(WdfCommonBufferGetLength), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfControlDeviceInitAllocate), WDFEXPORT(WdfControlDeviceInitSetShutdownNotification), WDFEXPORT(WdfControlFinishInitializing), @@ -6584,23 +7194,41 @@ WDFVERSION WdfVersion = { WDFEXPORT(WdfDeviceEnqueueRequest), WDFEXPORT(WdfDeviceGetDefaultQueue), WDFEXPORT(WdfDeviceConfigureRequestDispatching), - WDFEXPORT(WdfDmaEnablerCreate), - WDFEXPORT(WdfDmaEnablerGetMaximumLength), - WDFEXPORT(WdfDmaEnablerGetMaximumScatterGatherElements), - WDFEXPORT(WdfDmaEnablerSetMaximumScatterGatherElements), - WDFEXPORT(WdfDmaTransactionCreate), - WDFEXPORT(WdfDmaTransactionInitialize), - WDFEXPORT(WdfDmaTransactionInitializeUsingRequest), - WDFEXPORT(WdfDmaTransactionExecute), - WDFEXPORT(WdfDmaTransactionRelease), - WDFEXPORT(WdfDmaTransactionDmaCompleted), - WDFEXPORT(WdfDmaTransactionDmaCompletedWithLength), - WDFEXPORT(WdfDmaTransactionDmaCompletedFinal), - WDFEXPORT(WdfDmaTransactionGetBytesTransferred), - WDFEXPORT(WdfDmaTransactionSetMaximumLength), - WDFEXPORT(WdfDmaTransactionGetRequest), - WDFEXPORT(WdfDmaTransactionGetCurrentDmaTransferLength), - WDFEXPORT(WdfDmaTransactionGetDevice), + // WDFEXPORT(WdfDmaEnablerCreate), + // WDFEXPORT(WdfDmaEnablerGetMaximumLength), + // WDFEXPORT(WdfDmaEnablerGetMaximumScatterGatherElements), + // WDFEXPORT(WdfDmaEnablerSetMaximumScatterGatherElements), + // WDFEXPORT(WdfDmaTransactionCreate), + // WDFEXPORT(WdfDmaTransactionInitialize), + // WDFEXPORT(WdfDmaTransactionInitializeUsingRequest), + // WDFEXPORT(WdfDmaTransactionExecute), + // WDFEXPORT(WdfDmaTransactionRelease), + // WDFEXPORT(WdfDmaTransactionDmaCompleted), + // WDFEXPORT(WdfDmaTransactionDmaCompletedWithLength), + // WDFEXPORT(WdfDmaTransactionDmaCompletedFinal), + // WDFEXPORT(WdfDmaTransactionGetBytesTransferred), + // WDFEXPORT(WdfDmaTransactionSetMaximumLength), + // WDFEXPORT(WdfDmaTransactionGetRequest), + // WDFEXPORT(WdfDmaTransactionGetCurrentDmaTransferLength), + // WDFEXPORT(WdfDmaTransactionGetDevice), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfDpcCreate), WDFEXPORT(WdfDpcEnqueue), WDFEXPORT(WdfDpcCancel), @@ -6631,17 +7259,29 @@ WDFVERSION WdfVersion = { WDFEXPORT(WdfFileObjectGetFlags), WDFEXPORT(WdfFileObjectGetDevice), WDFEXPORT(WdfFileObjectWdmGetFileObject), - WDFEXPORT(WdfInterruptCreate), - WDFEXPORT(WdfInterruptQueueDpcForIsr), - WDFEXPORT(WdfInterruptSynchronize), - WDFEXPORT(WdfInterruptAcquireLock), - WDFEXPORT(WdfInterruptReleaseLock), - WDFEXPORT(WdfInterruptEnable), - WDFEXPORT(WdfInterruptDisable), - WDFEXPORT(WdfInterruptWdmGetInterrupt), - WDFEXPORT(WdfInterruptGetInfo), - WDFEXPORT(WdfInterruptSetPolicy), - WDFEXPORT(WdfInterruptGetDevice), + // WDFEXPORT(WdfInterruptCreate), + // WDFEXPORT(WdfInterruptQueueDpcForIsr), + // WDFEXPORT(WdfInterruptSynchronize), + // WDFEXPORT(WdfInterruptAcquireLock), + // WDFEXPORT(WdfInterruptReleaseLock), + // WDFEXPORT(WdfInterruptEnable), + // WDFEXPORT(WdfInterruptDisable), + // WDFEXPORT(WdfInterruptWdmGetInterrupt), + // WDFEXPORT(WdfInterruptGetInfo), + // WDFEXPORT(WdfInterruptSetPolicy), + // WDFEXPORT(WdfInterruptGetDevice), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfIoQueueCreate), WDFEXPORT(WdfIoQueueGetState), WDFEXPORT(WdfIoQueueStart), @@ -6776,28 +7416,51 @@ WDFVERSION WdfVersion = { WDFEXPORT(WdfRequestRequeue), WDFEXPORT(WdfRequestStopAcknowledge), WDFEXPORT(WdfRequestWdmGetIrp), - WDFEXPORT(WdfIoResourceRequirementsListSetSlotNumber), - WDFEXPORT(WdfIoResourceRequirementsListSetInterfaceType), - WDFEXPORT(WdfIoResourceRequirementsListAppendIoResList), - WDFEXPORT(WdfIoResourceRequirementsListInsertIoResList), - WDFEXPORT(WdfIoResourceRequirementsListGetCount), - WDFEXPORT(WdfIoResourceRequirementsListGetIoResList), - WDFEXPORT(WdfIoResourceRequirementsListRemove), - WDFEXPORT(WdfIoResourceRequirementsListRemoveByIoResList), - WDFEXPORT(WdfIoResourceListCreate), - WDFEXPORT(WdfIoResourceListAppendDescriptor), - WDFEXPORT(WdfIoResourceListInsertDescriptor), - WDFEXPORT(WdfIoResourceListUpdateDescriptor), - WDFEXPORT(WdfIoResourceListGetCount), - WDFEXPORT(WdfIoResourceListGetDescriptor), - WDFEXPORT(WdfIoResourceListRemove), - WDFEXPORT(WdfIoResourceListRemoveByDescriptor), - WDFEXPORT(WdfCmResourceListAppendDescriptor), - WDFEXPORT(WdfCmResourceListInsertDescriptor), - WDFEXPORT(WdfCmResourceListGetCount), - WDFEXPORT(WdfCmResourceListGetDescriptor), - WDFEXPORT(WdfCmResourceListRemove), - WDFEXPORT(WdfCmResourceListRemoveByDescriptor), + // WDFEXPORT(WdfIoResourceRequirementsListSetSlotNumber), + // WDFEXPORT(WdfIoResourceRequirementsListSetInterfaceType), + // WDFEXPORT(WdfIoResourceRequirementsListAppendIoResList), + // WDFEXPORT(WdfIoResourceRequirementsListInsertIoResList), + // WDFEXPORT(WdfIoResourceRequirementsListGetCount), + // WDFEXPORT(WdfIoResourceRequirementsListGetIoResList), + // WDFEXPORT(WdfIoResourceRequirementsListRemove), + // WDFEXPORT(WdfIoResourceRequirementsListRemoveByIoResList), + // WDFEXPORT(WdfIoResourceListCreate), + // WDFEXPORT(WdfIoResourceListAppendDescriptor), + // WDFEXPORT(WdfIoResourceListInsertDescriptor), + // WDFEXPORT(WdfIoResourceListUpdateDescriptor), + // WDFEXPORT(WdfIoResourceListGetCount), + // WDFEXPORT(WdfIoResourceListGetDescriptor), + // WDFEXPORT(WdfIoResourceListRemove), + // WDFEXPORT(WdfIoResourceListRemoveByDescriptor), + // WDFEXPORT(WdfCmResourceListAppendDescriptor), + // WDFEXPORT(WdfCmResourceListInsertDescriptor), + // WDFEXPORT(WdfCmResourceListGetCount), + // WDFEXPORT(WdfCmResourceListGetDescriptor), + // WDFEXPORT(WdfCmResourceListRemove), + // WDFEXPORT(WdfCmResourceListRemoveByDescriptor), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfStringCreate), WDFEXPORT(WdfStringGetUnicodeString), WDFEXPORT(WdfObjectAcquireLock), @@ -6812,116 +7475,213 @@ WDFVERSION WdfVersion = { WDFEXPORT(WdfTimerStart), WDFEXPORT(WdfTimerStop), WDFEXPORT(WdfTimerGetParentObject), - WDFEXPORT(WdfUsbTargetDeviceCreate), - WDFEXPORT(WdfUsbTargetDeviceRetrieveInformation), - WDFEXPORT(WdfUsbTargetDeviceGetDeviceDescriptor), - WDFEXPORT(WdfUsbTargetDeviceRetrieveConfigDescriptor), - WDFEXPORT(WdfUsbTargetDeviceQueryString), - WDFEXPORT(WdfUsbTargetDeviceAllocAndQueryString), - WDFEXPORT(WdfUsbTargetDeviceFormatRequestForString), - WDFEXPORT(WdfUsbTargetDeviceGetNumInterfaces), - WDFEXPORT(WdfUsbTargetDeviceSelectConfig), - WDFEXPORT(WdfUsbTargetDeviceWdmGetConfigurationHandle), - WDFEXPORT(WdfUsbTargetDeviceRetrieveCurrentFrameNumber), - WDFEXPORT(WdfUsbTargetDeviceSendControlTransferSynchronously), - WDFEXPORT(WdfUsbTargetDeviceFormatRequestForControlTransfer), - WDFEXPORT(WdfUsbTargetDeviceIsConnectedSynchronous), - WDFEXPORT(WdfUsbTargetDeviceResetPortSynchronously), - WDFEXPORT(WdfUsbTargetDeviceCyclePortSynchronously), - WDFEXPORT(WdfUsbTargetDeviceFormatRequestForCyclePort), - WDFEXPORT(WdfUsbTargetDeviceSendUrbSynchronously), - WDFEXPORT(WdfUsbTargetDeviceFormatRequestForUrb), - WDFEXPORT(WdfUsbTargetPipeGetInformation), - WDFEXPORT(WdfUsbTargetPipeIsInEndpoint), - WDFEXPORT(WdfUsbTargetPipeIsOutEndpoint), - WDFEXPORT(WdfUsbTargetPipeGetType), - WDFEXPORT(WdfUsbTargetPipeSetNoMaximumPacketSizeCheck), - WDFEXPORT(WdfUsbTargetPipeWriteSynchronously), - WDFEXPORT(WdfUsbTargetPipeFormatRequestForWrite), - WDFEXPORT(WdfUsbTargetPipeReadSynchronously), - WDFEXPORT(WdfUsbTargetPipeFormatRequestForRead), - WDFEXPORT(WdfUsbTargetPipeConfigContinuousReader), - WDFEXPORT(WdfUsbTargetPipeAbortSynchronously), - WDFEXPORT(WdfUsbTargetPipeFormatRequestForAbort), - WDFEXPORT(WdfUsbTargetPipeResetSynchronously), - WDFEXPORT(WdfUsbTargetPipeFormatRequestForReset), - WDFEXPORT(WdfUsbTargetPipeSendUrbSynchronously), - WDFEXPORT(WdfUsbTargetPipeFormatRequestForUrb), - WDFEXPORT(WdfUsbInterfaceGetInterfaceNumber), - WDFEXPORT(WdfUsbInterfaceGetNumEndpoints), - WDFEXPORT(WdfUsbInterfaceGetDescriptor), - WDFEXPORT(WdfUsbInterfaceSelectSetting), - WDFEXPORT(WdfUsbInterfaceGetEndpointInformation), - WDFEXPORT(WdfUsbTargetDeviceGetInterface), - WDFEXPORT(WdfUsbInterfaceGetConfiguredSettingIndex), - WDFEXPORT(WdfUsbInterfaceGetNumConfiguredPipes), - WDFEXPORT(WdfUsbInterfaceGetConfiguredPipe), - WDFEXPORT(WdfUsbTargetPipeWdmGetPipeHandle), - WDFEXPORT(WdfVerifierDbgBreakPoint), - WDFEXPORT(WdfVerifierKeBugCheck), - WDFEXPORT(WdfWmiProviderCreate), - WDFEXPORT(WdfWmiProviderGetDevice), - WDFEXPORT(WdfWmiProviderIsEnabled), - WDFEXPORT(WdfWmiProviderGetTracingHandle), - WDFEXPORT(WdfWmiInstanceCreate), - WDFEXPORT(WdfWmiInstanceRegister), - WDFEXPORT(WdfWmiInstanceDeregister), - WDFEXPORT(WdfWmiInstanceGetDevice), - WDFEXPORT(WdfWmiInstanceGetProvider), - WDFEXPORT(WdfWmiInstanceFireEvent), + // WDFEXPORT(WdfUsbTargetDeviceCreate), + // WDFEXPORT(WdfUsbTargetDeviceRetrieveInformation), + // WDFEXPORT(WdfUsbTargetDeviceGetDeviceDescriptor), + // WDFEXPORT(WdfUsbTargetDeviceRetrieveConfigDescriptor), + // WDFEXPORT(WdfUsbTargetDeviceQueryString), + // WDFEXPORT(WdfUsbTargetDeviceAllocAndQueryString), + // WDFEXPORT(WdfUsbTargetDeviceFormatRequestForString), + // WDFEXPORT(WdfUsbTargetDeviceGetNumInterfaces), + // WDFEXPORT(WdfUsbTargetDeviceSelectConfig), + // WDFEXPORT(WdfUsbTargetDeviceWdmGetConfigurationHandle), + // WDFEXPORT(WdfUsbTargetDeviceRetrieveCurrentFrameNumber), + // WDFEXPORT(WdfUsbTargetDeviceSendControlTransferSynchronously), + // WDFEXPORT(WdfUsbTargetDeviceFormatRequestForControlTransfer), + // WDFEXPORT(WdfUsbTargetDeviceIsConnectedSynchronous), + // WDFEXPORT(WdfUsbTargetDeviceResetPortSynchronously), + // WDFEXPORT(WdfUsbTargetDeviceCyclePortSynchronously), + // WDFEXPORT(WdfUsbTargetDeviceFormatRequestForCyclePort), + // WDFEXPORT(WdfUsbTargetDeviceSendUrbSynchronously), + // WDFEXPORT(WdfUsbTargetDeviceFormatRequestForUrb), + // WDFEXPORT(WdfUsbTargetPipeGetInformation), + // WDFEXPORT(WdfUsbTargetPipeIsInEndpoint), + // WDFEXPORT(WdfUsbTargetPipeIsOutEndpoint), + // WDFEXPORT(WdfUsbTargetPipeGetType), + // WDFEXPORT(WdfUsbTargetPipeSetNoMaximumPacketSizeCheck), + // WDFEXPORT(WdfUsbTargetPipeWriteSynchronously), + // WDFEXPORT(WdfUsbTargetPipeFormatRequestForWrite), + // WDFEXPORT(WdfUsbTargetPipeReadSynchronously), + // WDFEXPORT(WdfUsbTargetPipeFormatRequestForRead), + // WDFEXPORT(WdfUsbTargetPipeConfigContinuousReader), + // WDFEXPORT(WdfUsbTargetPipeAbortSynchronously), + // WDFEXPORT(WdfUsbTargetPipeFormatRequestForAbort), + // WDFEXPORT(WdfUsbTargetPipeResetSynchronously), + // WDFEXPORT(WdfUsbTargetPipeFormatRequestForReset), + // WDFEXPORT(WdfUsbTargetPipeSendUrbSynchronously), + // WDFEXPORT(WdfUsbTargetPipeFormatRequestForUrb), + // WDFEXPORT(WdfUsbInterfaceGetInterfaceNumber), + // WDFEXPORT(WdfUsbInterfaceGetNumEndpoints), + // WDFEXPORT(WdfUsbInterfaceGetDescriptor), + // WDFEXPORT(WdfUsbInterfaceSelectSetting), + // WDFEXPORT(WdfUsbInterfaceGetEndpointInformation), + // WDFEXPORT(WdfUsbTargetDeviceGetInterface), + // WDFEXPORT(WdfUsbInterfaceGetConfiguredSettingIndex), + // WDFEXPORT(WdfUsbInterfaceGetNumConfiguredPipes), + // WDFEXPORT(WdfUsbInterfaceGetConfiguredPipe), + // WDFEXPORT(WdfUsbTargetPipeWdmGetPipeHandle), + // WDFEXPORT(WdfVerifierDbgBreakPoint), + // WDFEXPORT(WdfVerifierKeBugCheck), + // WDFEXPORT(WdfWmiProviderCreate), + // WDFEXPORT(WdfWmiProviderGetDevice), + // WDFEXPORT(WdfWmiProviderIsEnabled), + // WDFEXPORT(WdfWmiProviderGetTracingHandle), + // WDFEXPORT(WdfWmiInstanceCreate), + // WDFEXPORT(WdfWmiInstanceRegister), + // WDFEXPORT(WdfWmiInstanceDeregister), + // WDFEXPORT(WdfWmiInstanceGetDevice), + // WDFEXPORT(WdfWmiInstanceGetProvider), + // WDFEXPORT(WdfWmiInstanceFireEvent), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfWorkItemCreate), WDFEXPORT(WdfWorkItemEnqueue), WDFEXPORT(WdfWorkItemGetParentObject), WDFEXPORT(WdfWorkItemFlush), - WDFEXPORT(WdfCommonBufferCreateWithConfig), - WDFEXPORT(WdfDmaEnablerGetFragmentLength), - WDFEXPORT(WdfDmaEnablerWdmGetDmaAdapter), - WDFEXPORT(WdfUsbInterfaceGetNumSettings), + // WDFEXPORT(WdfCommonBufferCreateWithConfig), + // WDFEXPORT(WdfDmaEnablerGetFragmentLength), + // WDFEXPORT(WdfDmaEnablerWdmGetDmaAdapter), + // WDFEXPORT(WdfUsbInterfaceGetNumSettings), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfDeviceRemoveDependentUsageDeviceObject), WDFEXPORT(WdfDeviceGetSystemPowerAction), - WDFEXPORT(WdfInterruptSetExtendedPolicy), + // WDFEXPORT(WdfInterruptSetExtendedPolicy), + WdfApiNotImplemented, + WDFEXPORT(WdfIoQueueAssignForwardProgressPolicy), WDFEXPORT(WdfPdoInitAssignContainerID), WDFEXPORT(WdfPdoInitAllowForwardingRequestToParent), WDFEXPORT(WdfRequestMarkCancelableEx), WDFEXPORT(WdfRequestIsReserved), WDFEXPORT(WdfRequestForwardToParentDeviceIoQueue), - WDFEXPORT(WdfCxDeviceInitAllocate), - WDFEXPORT(WdfCxDeviceInitAssignWdmIrpPreprocessCallback), - WDFEXPORT(WdfCxDeviceInitSetIoInCallerContextCallback), - WDFEXPORT(WdfCxDeviceInitSetRequestAttributes), - WDFEXPORT(WdfCxDeviceInitSetFileObjectConfig), + // WDFEXPORT(WdfCxDeviceInitAllocate), + // WDFEXPORT(WdfCxDeviceInitAssignWdmIrpPreprocessCallback), + // WDFEXPORT(WdfCxDeviceInitSetIoInCallerContextCallback), + // WDFEXPORT(WdfCxDeviceInitSetRequestAttributes), + // WDFEXPORT(WdfCxDeviceInitSetFileObjectConfig), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfDeviceWdmDispatchIrp), WDFEXPORT(WdfDeviceWdmDispatchIrpToIoQueue), WDFEXPORT(WdfDeviceInitSetRemoveLockOptions), WDFEXPORT(WdfDeviceConfigureWdmIrpDispatchCallback), - WDFEXPORT(WdfDmaEnablerConfigureSystemProfile), - WDFEXPORT(WdfDmaTransactionInitializeUsingOffset), - WDFEXPORT(WdfDmaTransactionGetTransferInfo), - WDFEXPORT(WdfDmaTransactionSetChannelConfigurationCallback), - WDFEXPORT(WdfDmaTransactionSetTransferCompleteCallback), - WDFEXPORT(WdfDmaTransactionSetImmediateExecution), - WDFEXPORT(WdfDmaTransactionAllocateResources), - WDFEXPORT(WdfDmaTransactionSetDeviceAddressOffset), - WDFEXPORT(WdfDmaTransactionFreeResources), - WDFEXPORT(WdfDmaTransactionCancel), - WDFEXPORT(WdfDmaTransactionWdmGetTransferContext), - WDFEXPORT(WdfInterruptQueueWorkItemForIsr), - WDFEXPORT(WdfInterruptTryToAcquireLock), + // WDFEXPORT(WdfDmaEnablerConfigureSystemProfile), + // WDFEXPORT(WdfDmaTransactionInitializeUsingOffset), + // WDFEXPORT(WdfDmaTransactionGetTransferInfo), + // WDFEXPORT(WdfDmaTransactionSetChannelConfigurationCallback), + // WDFEXPORT(WdfDmaTransactionSetTransferCompleteCallback), + // WDFEXPORT(WdfDmaTransactionSetImmediateExecution), + // WDFEXPORT(WdfDmaTransactionAllocateResources), + // WDFEXPORT(WdfDmaTransactionSetDeviceAddressOffset), + // WDFEXPORT(WdfDmaTransactionFreeResources), + // WDFEXPORT(WdfDmaTransactionCancel), + // WDFEXPORT(WdfDmaTransactionWdmGetTransferContext), + // WDFEXPORT(WdfInterruptQueueWorkItemForIsr), + // WDFEXPORT(WdfInterruptTryToAcquireLock), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfIoQueueStopAndPurge), WDFEXPORT(WdfIoQueueStopAndPurgeSynchronously), WDFEXPORT(WdfIoTargetPurge), - WDFEXPORT(WdfUsbTargetDeviceCreateWithParameters), - WDFEXPORT(WdfUsbTargetDeviceQueryUsbCapability), - WDFEXPORT(WdfUsbTargetDeviceCreateUrb), - WDFEXPORT(WdfUsbTargetDeviceCreateIsochUrb), + // WDFEXPORT(WdfUsbTargetDeviceCreateWithParameters), + // WDFEXPORT(WdfUsbTargetDeviceQueryUsbCapability), + // WDFEXPORT(WdfUsbTargetDeviceCreateUrb), + // WDFEXPORT(WdfUsbTargetDeviceCreateIsochUrb), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfDeviceWdmAssignPowerFrameworkSettings), - WDFEXPORT(WdfDmaTransactionStopSystemTransfer), - WDFEXPORT(WdfCxVerifierKeBugCheck), - WDFEXPORT(WdfInterruptReportActive), - WDFEXPORT(WdfInterruptReportInactive), + // WDFEXPORT(WdfDmaTransactionStopSystemTransfer), + // WDFEXPORT(WdfCxVerifierKeBugCheck), + // WDFEXPORT(WdfInterruptReportActive), + // WDFEXPORT(WdfInterruptReportInactive), + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WdfApiNotImplemented, + WDFEXPORT(WdfDeviceInitSetReleaseHardwareOrderOnFailure), - WDFEXPORT(WdfGetTriageInfo), + // WDFEXPORT(WdfGetTriageInfo), + WdfApiNotImplemented, + WDFEXPORT(WdfDeviceInitSetIoTypeEx), WDFEXPORT(WdfDeviceQueryPropertyEx), WDFEXPORT(WdfDeviceAllocAndQueryPropertyEx), diff --git a/sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamicswrapper.h b/sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamicswrapper.h index c409d2d04e7..2ac479dc49c 100644 --- a/sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamicswrapper.h +++ b/sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamicswrapper.h @@ -7,12 +7,10 @@ // extern "C" { -#pragma warning(disable:4200) // zero-sized array in struct/union #include -#pragma warning(default:4200) #include #include -#include "FxDynamics.h" -#include "VfFxDynamics.h" +#include "fxdynamics.h" +#include "vffxdynamics.h" } diff --git a/sdk/lib/drivers/wdf/kmdf/inc/private/fxprobeandlock.h b/sdk/lib/drivers/wdf/kmdf/inc/private/fxprobeandlock.h index 4a612acba0c..214064a7342 100644 --- a/sdk/lib/drivers/wdf/kmdf/inc/private/fxprobeandlock.h +++ b/sdk/lib/drivers/wdf/kmdf/inc/private/fxprobeandlock.h @@ -35,4 +35,4 @@ FxProbeAndLockWithAccess( } -#endif __FXPROBEANDLOCK_H__ +#endif // __FXPROBEANDLOCK_H__ diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/fxbugcheckcallback.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/fxbugcheckcallback.cpp index 1a9935e4e8b..d164d682a05 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/fxbugcheckcallback.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/fxbugcheckcallback.cpp @@ -20,12 +20,12 @@ Revision History: #include "fxcorepch.hpp" -#include "FxIFR.h" -#include "fxIFRKm.h" // kernel mode only IFR definitions -#include "FxLdr.h" -#include "FxBugcheck.h" +#include "fxifr.h" +#include "fxifrkm.h" // kernel mode only IFR definitions +#include "fxldr.h" +#include "fxbugcheck.h" -#include +// #include // // Disable warnings of features used by the standard headers @@ -35,9 +35,9 @@ Revision History: // Disable warning C4201: nonstandard extension used : nameless struct/union // Disable warning C4214: nonstandard extension used : bit field types other than int // -#pragma warning(disable:4115 4200 4201 4214) +// #pragma warning(disable:4115 4200 4201 4214) #include -#pragma warning(default:4115 4200 4201 4214) +// #pragma warning(default:4115 4200 4201 4214) extern "C" { @@ -125,102 +125,104 @@ FxpGetImageBase( __out PULONG ImageSize ) { - NTSTATUS status = STATUS_UNSUCCESSFUL; - ULONG modulesSize = 0; - AUX_MODULE_EXTENDED_INFO* modules = NULL; - AUX_MODULE_EXTENDED_INFO* module; - PVOID addressInImage = NULL; - ULONG numberOfModules; - ULONG i; +// NTSTATUS status = STATUS_UNSUCCESSFUL; +// ULONG modulesSize = 0; +// AUX_MODULE_EXTENDED_INFO* modules = NULL; +// AUX_MODULE_EXTENDED_INFO* module; +// PVOID addressInImage = NULL; +// ULONG numberOfModules; +// ULONG i; - // - // Basic validation. - // - if (NULL == DriverObject || NULL == ImageBase || NULL == ImageSize) { - status = STATUS_INVALID_PARAMETER; - goto exit; - } +// // +// // Basic validation. +// // +// if (NULL == DriverObject || NULL == ImageBase || NULL == ImageSize) { +// status = STATUS_INVALID_PARAMETER; +// goto exit; +// } - // - // Get the address of a well known entry in the Image. - // - addressInImage = (PVOID) DriverObject->DriverStart; - ASSERT(addressInImage != NULL); +// // +// // Get the address of a well known entry in the Image. +// // +// addressInImage = (PVOID) DriverObject->DriverStart; +// ASSERT(addressInImage != NULL); - // - // Initialize the AUX Kernel Library. - // - status = AuxKlibInitialize(); - if (!NT_SUCCESS(status)) { - goto exit; - } +// // +// // Initialize the AUX Kernel Library. +// // +// status = AuxKlibInitialize(); +// if (!NT_SUCCESS(status)) { +// goto exit; +// } - // - // Get size of area needed for loaded modules. - // - status = AuxKlibQueryModuleInformation(&modulesSize, - sizeof(AUX_MODULE_EXTENDED_INFO), - NULL); +// // +// // Get size of area needed for loaded modules. +// // +// status = AuxKlibQueryModuleInformation(&modulesSize, +// sizeof(AUX_MODULE_EXTENDED_INFO), +// NULL); - if (!NT_SUCCESS(status) || (0 == modulesSize)) { - goto exit; - } +// if (!NT_SUCCESS(status) || (0 == modulesSize)) { +// goto exit; +// } - numberOfModules = modulesSize / sizeof(AUX_MODULE_EXTENDED_INFO); +// numberOfModules = modulesSize / sizeof(AUX_MODULE_EXTENDED_INFO); - // - // Allocate returned-sized memory for the modules area. - // - modules = (AUX_MODULE_EXTENDED_INFO*) ExAllocatePoolWithTag(PagedPool, - modulesSize, - '30LW'); - if (NULL == modules) { - status = STATUS_INSUFFICIENT_RESOURCES; - goto exit; - } +// // +// // Allocate returned-sized memory for the modules area. +// // +// modules = (AUX_MODULE_EXTENDED_INFO*) ExAllocatePoolWithTag(PagedPool, +// modulesSize, +// '30LW'); +// if (NULL == modules) { +// status = STATUS_INSUFFICIENT_RESOURCES; +// goto exit; +// } - // - // Request the modules array be filled with module information. - // - status = AuxKlibQueryModuleInformation(&modulesSize, - sizeof(AUX_MODULE_EXTENDED_INFO), - modules); +// // +// // Request the modules array be filled with module information. +// // +// status = AuxKlibQueryModuleInformation(&modulesSize, +// sizeof(AUX_MODULE_EXTENDED_INFO), +// modules); - if (!NT_SUCCESS(status)) { - goto exit; - } +// if (!NT_SUCCESS(status)) { +// goto exit; +// } - // - // Traverse list, searching for the well known address in Image for which the - // module's Image Base Address is in its range. - // - module = modules; +// // +// // Traverse list, searching for the well known address in Image for which the +// // module's Image Base Address is in its range. +// // +// module = modules; - for (i=0; i < numberOfModules; i++) { +// for (i=0; i < numberOfModules; i++) { - if (addressInImage >= module->BasicInfo.ImageBase && - addressInImage < WDF_PTR_ADD_OFFSET(module->BasicInfo.ImageBase, - module->ImageSize)) { +// if (addressInImage >= module->BasicInfo.ImageBase && +// addressInImage < WDF_PTR_ADD_OFFSET(module->BasicInfo.ImageBase, +// module->ImageSize)) { - *ImageBase = module->BasicInfo.ImageBase; - *ImageSize = module->ImageSize; +// *ImageBase = module->BasicInfo.ImageBase; +// *ImageSize = module->ImageSize; - status = STATUS_SUCCESS; - goto exit; - } - module++; - } +// status = STATUS_SUCCESS; +// goto exit; +// } +// module++; +// } - status = STATUS_NOT_FOUND; +// status = STATUS_NOT_FOUND; -exit: +// exit: - if (modules != NULL) { - ExFreePool(modules); - modules = NULL; - } +// if (modules != NULL) { +// ExFreePool(modules); +// modules = NULL; +// } - return status; +// return status; + ROSWDFNOTIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; } _Must_inspect_result_ @@ -246,77 +248,65 @@ Return Value: --*/ { - PVOID codeAddr = NULL; - BOOLEAN found = FALSE; - KBUGCHECK_DATA bugCheckData = {0}; + // PVOID codeAddr = NULL; + // BOOLEAN found = FALSE; + // KBUGCHECK_DATA bugCheckData = {0}; - if (FxDriverGlobals->FxForceLogsInMiniDump) { - return TRUE; - } + // if (FxDriverGlobals->FxForceLogsInMiniDump) { + // return TRUE; + // } - // - // Retrieve the bugcheck parameters. - // - bugCheckData.BugCheckDataSize = sizeof(KBUGCHECK_DATA); - AuxKlibGetBugCheckData(&bugCheckData); + // // + // // Retrieve the bugcheck parameters. + // // + // bugCheckData.BugCheckDataSize = sizeof(KBUGCHECK_DATA); + // AuxKlibGetBugCheckData(&bugCheckData); - // - // Check whether the code address that caused the bugcheck is from this wdf - // driver. - // - switch (bugCheckData.BugCheckCode) { + // // + // // Check whether the code address that caused the bugcheck is from this wdf + // // driver. + // // + // switch (bugCheckData.BugCheckCode) { - case KERNEL_APC_PENDING_DURING_EXIT: // 0x20 - codeAddr = (PVOID)bugCheckData.Parameter1; - found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals); - break; + // case KERNEL_APC_PENDING_DURING_EXIT: // 0x20 + // codeAddr = (PVOID)bugCheckData.Parameter1; + // found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals); + // break; - case KMODE_EXCEPTION_NOT_HANDLED: // 0x1E - case SYSTEM_THREAD_EXCEPTION_NOT_HANDLED: // 0x7E - case KERNEL_MODE_EXCEPTION_NOT_HANDLED: // 0x8E - codeAddr = (PVOID)bugCheckData.Parameter2; - found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals); - break; + // case KMODE_EXCEPTION_NOT_HANDLED: // 0x1E + // case SYSTEM_THREAD_EXCEPTION_NOT_HANDLED: // 0x7E + // case KERNEL_MODE_EXCEPTION_NOT_HANDLED: // 0x8E + // codeAddr = (PVOID)bugCheckData.Parameter2; + // found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals); + // break; - case PAGE_FAULT_IN_NONPAGED_AREA: // 0x50 - codeAddr = (PVOID)bugCheckData.Parameter3; - found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals); - break; + // case PAGE_FAULT_IN_NONPAGED_AREA: // 0x50 + // codeAddr = (PVOID)bugCheckData.Parameter3; + // found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals); + // break; - case IRQL_NOT_LESS_OR_EQUAL: // 0xA - case DRIVER_IRQL_NOT_LESS_OR_EQUAL: // 0xD1 - codeAddr = (PVOID)bugCheckData.Parameter4; - found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals); - break; - } + // case IRQL_NOT_LESS_OR_EQUAL: // 0xA + // case DRIVER_IRQL_NOT_LESS_OR_EQUAL: // 0xD1 + // codeAddr = (PVOID)bugCheckData.Parameter4; + // found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals); + // break; + // } - // - // If the code address was found in the wdf driver, then set the flag in the - // driver globals to indicate that the IFR data has to be written to the - // mini-dump. - // - if (found) { - FxDriverGlobals->FxForceLogsInMiniDump = TRUE; - } - - - - - - - - - - - - - - - - return found; + // // + // // If the code address was found in the wdf driver, then set the flag in the + // // driver globals to indicate that the IFR data has to be written to the + // // mini-dump. + // // + // if (found) { + // FxDriverGlobals->FxForceLogsInMiniDump = TRUE; + // } + // return found; + ROSWDFNOTIMPLEMENTED; + return FALSE; } VOID +STDCALL FxpBugCheckCallback( __in KBUGCHECK_CALLBACK_REASON Reason, __in PKBUGCHECK_REASON_CALLBACK_RECORD Record, @@ -567,6 +557,7 @@ Done:; } VOID +STDCALL FxpLibraryBugCheckCallback( __in KBUGCHECK_CALLBACK_REASON Reason, __in PKBUGCHECK_REASON_CALLBACK_RECORD /* Record */, @@ -1043,7 +1034,7 @@ FX_DRIVER_TRACKER_CACHE_AWARE::Register( // // Intialize the procgrp down level library. // - WdmlibProcgrpInitialize(); + // WdmlibProcgrpInitialize(); __REACTOS__ : haha we don't support ProcGrp // // Capture maximum number of processors. diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/fxchildlist.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/fxchildlist.cpp index d5adf0fa7d2..e749b7c9a3f 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/fxchildlist.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/fxchildlist.cpp @@ -25,7 +25,7 @@ Revision History: #include "fxcorepch.hpp" extern "C" { -#include "FxChildList.tmh" +// #include "FxChildList.tmh" } FxDeviceDescriptionEntry::FxDeviceDescriptionEntry( @@ -1145,9 +1145,6 @@ FxChildList::GetNextStaticDevice( for (ple = m_ModificationListHead.Flink; ple != &m_ModificationListHead; ple = ple->Flink) { - BOOLEAN check; - - check = FALSE; pEntry = FxDeviceDescriptionEntry::_FromModificationLink(ple); diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/fxchildlistapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/fxchildlistapi.cpp index 7d04ec796ae..2a3fe432040 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/fxchildlistapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/fxchildlistapi.cpp @@ -25,7 +25,7 @@ Revision History: #include "fxcorepch.hpp" extern "C" { -#include "FxChildListAPI.tmh" +// #include "FxChildListAPI.tmh" } // @@ -36,6 +36,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfChildListCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -125,6 +126,7 @@ WDFEXPORT(WdfChildListCreate)( __drv_maxIRQL(DISPATCH_LEVEL) WDFDEVICE +STDCALL WDFEXPORT(WdfChildListGetDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -150,6 +152,7 @@ WDFEXPORT(WdfChildListGetDevice)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfChildListRetrieveAddressDescription)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -226,6 +229,7 @@ WDFEXPORT(WdfChildListRetrieveAddressDescription)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfChildListBeginScan)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -250,6 +254,7 @@ WDFEXPORT(WdfChildListBeginScan)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfChildListEndScan)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -274,6 +279,7 @@ WDFEXPORT(WdfChildListEndScan)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfChildListBeginIteration)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -323,6 +329,7 @@ WDFEXPORT(WdfChildListBeginIteration)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfChildListRetrieveNextDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -425,6 +432,7 @@ WDFEXPORT(WdfChildListRetrieveNextDevice)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfChildListEndIteration)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -473,6 +481,7 @@ WDFEXPORT(WdfChildListEndIteration)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfChildListAddOrUpdateChildDescriptionAsPresent)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -561,6 +570,7 @@ WDFEXPORT(WdfChildListAddOrUpdateChildDescriptionAsPresent)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfChildListUpdateChildDescriptionAsMissing)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -609,6 +619,7 @@ WDFEXPORT(WdfChildListUpdateChildDescriptionAsMissing)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfChildListUpdateAllChildDescriptionsAsPresent)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -637,6 +648,7 @@ WDFEXPORT(WdfChildListUpdateAllChildDescriptionsAsPresent)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFDEVICE +STDCALL WDFEXPORT(WdfChildListRetrievePdo)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -734,6 +746,7 @@ WDFEXPORT(WdfChildListRetrievePdo)( __drv_maxIRQL(DISPATCH_LEVEL) BOOLEAN +STDCALL WDFEXPORT(WdfChildListRequestChildEject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/fxdevicefdoapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/fxdevicefdoapi.cpp index 509d19dd368..71673c4bdbc 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/fxdevicefdoapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/fxdevicefdoapi.cpp @@ -25,7 +25,7 @@ Revision History: #include "fxcorepch.hpp" extern "C" { -#include "FxDeviceFdoApi.tmh" +// #include "FxDeviceFdoApi.tmh" } // @@ -36,6 +36,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfFdoAddStaticChild)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -121,6 +122,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfFdoLockStaticChildListForIteration)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -179,6 +181,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFDEVICE +STDCALL WDFEXPORT(WdfFdoRetrieveNextStaticChild)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -256,6 +259,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfFdoUnlockStaticChildListFromIteration)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -311,6 +315,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfFdoQueryForInterface)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -405,6 +410,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) WDFCHILDLIST +STDCALL WDFEXPORT(WdfFdoGetDefaultChildList)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/fxdevicepdoapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/fxdevicepdoapi.cpp index c33c614e290..f9dc29fee76 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/fxdevicepdoapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/fxdevicepdoapi.cpp @@ -25,7 +25,7 @@ Revision History: #include "fxcorepch.hpp" extern "C" { -#include "FxDevicePdoApi.tmh" +// #include "FxDevicePdoApi.tmh" } NTSTATUS @@ -87,6 +87,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoMarkMissing)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -101,7 +102,7 @@ WDFEXPORT(WdfPdoMarkMissing)( status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals, &pDevice); @@ -120,6 +121,7 @@ WDFEXPORT(WdfPdoMarkMissing)( __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfPdoRequestEject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -134,7 +136,7 @@ WDFEXPORT(WdfPdoRequestEject)( status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals, &pDevice); @@ -163,6 +165,7 @@ WDFEXPORT(WdfPdoRequestEject)( __drv_maxIRQL(DISPATCH_LEVEL) WDFDEVICE +STDCALL WDFEXPORT(WdfPdoGetParent)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -177,7 +180,7 @@ WDFEXPORT(WdfPdoGetParent)( status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals, &pDevice); @@ -197,6 +200,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoRetrieveIdentificationDescription)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -212,7 +216,7 @@ WDFEXPORT(WdfPdoRetrieveIdentificationDescription)( status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals); @@ -251,6 +255,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoRetrieveAddressDescription)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -266,7 +271,7 @@ WDFEXPORT(WdfPdoRetrieveAddressDescription)( status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals); @@ -307,6 +312,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfPdoUpdateAddressDescription)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -322,7 +328,7 @@ WDFEXPORT(WdfPdoUpdateAddressDescription)( status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals); @@ -354,6 +360,7 @@ WDFEXPORT(WdfPdoUpdateAddressDescription)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoAddEjectionRelationsPhysicalDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -386,7 +393,7 @@ Return Value: status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals); @@ -403,6 +410,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfPdoRemoveEjectionRelationsPhysicalDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -434,7 +442,7 @@ Return Value: status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals); @@ -449,6 +457,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfPdoClearEjectionRelationsDevices)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -476,7 +485,7 @@ Return Value: status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals), Device, - __FUNCTION__, + (PCHAR)__FUNCTION__, &pPkgPdo, &pFxDriverGlobals); diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/fxdpc.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/fxdpc.cpp index e1d6e165a16..3f264368d10 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/fxdpc.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/fxdpc.cpp @@ -26,11 +26,11 @@ Revision History: #include "fxcorepch.hpp" -#include "FxDpc.hpp" +#include "fxdpc.hpp" // Tracing support extern "C" { -#include "FxDpc.tmh" +// #include "FxDpc.tmh" } // diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/fxdpcapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/fxdpcapi.cpp index 36cdfe34e0f..8172b8e8329 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/fxdpcapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/fxdpcapi.cpp @@ -25,10 +25,10 @@ Revision History: #include "fxcorepch.hpp" -#include "FxDpc.hpp" +#include "fxdpc.hpp" extern "C" { -#include "FxDpcApi.tmh" +// #include "FxDpcApi.tmh" } // @@ -39,6 +39,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDpcCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -129,6 +130,7 @@ Notes: __drv_maxIRQL(HIGH_LEVEL) KDPC* +STDCALL WDFEXPORT(WdfDpcWdmGetDpc)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -166,6 +168,7 @@ Returns: __drv_maxIRQL(HIGH_LEVEL) BOOLEAN +STDCALL WDFEXPORT(WdfDpcEnqueue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -202,6 +205,7 @@ Returns: __drv_when(Wait == __true, __drv_maxIRQL(PASSIVE_LEVEL)) __drv_when(Wait == __false, __drv_maxIRQL(HIGH_LEVEL)) BOOLEAN +STDCALL WDFEXPORT(WdfDpcCancel)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -254,6 +258,7 @@ Returns: __drv_maxIRQL(HIGH_LEVEL) WDFOBJECT +STDCALL WDFEXPORT(WdfDpcGetParentObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/fxsystemthread.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/fxsystemthread.cpp index accdd17aa72..18bf09d4334 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/fxsystemthread.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/fxsystemthread.cpp @@ -27,7 +27,7 @@ Revision History: #include "fxcorepch.hpp" extern "C" { -#include "FxSystemThread.tmh" +// #include "FxSystemThread.tmh" } @@ -151,7 +151,7 @@ FxSystemThread::CreateThread( // // The thread itself will release this reference in its exit routine // - ADDREF(FxSystemThread::StaticThreadThunk); + ADDREF((PVOID)FxSystemThread::StaticThreadThunk); status = PsCreateSystemThread( &threadHandle, @@ -171,7 +171,7 @@ FxSystemThread::CreateThread( // // Release the reference taken above due to failure // - RELEASE(FxSystemThread::StaticThreadThunk); + RELEASE((PVOID)FxSystemThread::StaticThreadThunk); } else { status = ObReferenceObjectByHandle( @@ -347,7 +347,7 @@ FxSystemThread::ExitThreadAsync( m_Exit = TRUE; // Add a reference which will be released by the reaper - ADDREF(FxSystemThread::StaticReaperThunk); + ADDREF((PVOID)FxSystemThread::StaticReaperThunk); Unlock(irql); @@ -524,7 +524,7 @@ FxSystemThread::Thread() Unlock(irql); // Release the object reference held by the thread - RELEASE(FxSystemThread::StaticThreadThunk); + RELEASE((PVOID)FxSystemThread::StaticThreadThunk); status = PsTerminateSystemThread(STATUS_SUCCESS); UNREFERENCED_PARAMETER(status); @@ -635,7 +635,7 @@ FxSystemThread::Reaper() ObDereferenceObject(m_ThreadPtr); - RELEASE(FxSystemThread::StaticReaperThunk); + RELEASE((PVOID)FxSystemThread::StaticReaperThunk); return; } diff --git a/sdk/lib/drivers/wdf/kmdf/src/core/tracing.cpp b/sdk/lib/drivers/wdf/kmdf/src/core/tracing.cpp index 8b1e10c35fe..cd1f604218a 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/core/tracing.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/core/tracing.cpp @@ -30,12 +30,12 @@ Revision History: // We use DoTraceMessage extern "C" { -#include "tracing.tmh" +// #include "tracing.tmh" } #include -#include "fxIFR.h" // shared struct between IFR and debug ext. -#include "fxIFRKm.h" // kernel mode only IFR definitions +#include "fxifr.h" // shared struct between IFR and debug ext. +#include "fxifrkm.h" // kernel mode only IFR definitions //============================================================================= diff --git a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbuffer.cpp b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbuffer.cpp index db36b0f2fb3..1011d97c728 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbuffer.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbuffer.cpp @@ -21,10 +21,10 @@ Revision History: --*/ -#include "FxDmaPCH.hpp" +#include "fxdmapch.hpp" extern "C" { -#include "FxCommonBuffer.tmh" +// #include "FxCommonBuffer.tmh" } FxCommonBuffer::FxCommonBuffer( diff --git a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbufferapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbufferapi.cpp index 58189ec61b1..797ca7061f6 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbufferapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbufferapi.cpp @@ -21,10 +21,10 @@ Revision History: --*/ -#include "FxDmaPCH.hpp" +#include "fxdmapch.hpp" extern "C" { -#include "FxCommonBufferAPI.tmh" +// #include "FxCommonBufferAPI.tmh" } // @@ -35,6 +35,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfCommonBufferCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -134,6 +135,7 @@ WDFEXPORT(WdfCommonBufferCreate)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfCommonBufferCreateWithConfig)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -245,6 +247,7 @@ WDFEXPORT(WdfCommonBufferCreateWithConfig)( __drv_maxIRQL(DISPATCH_LEVEL) PVOID +STDCALL WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -264,6 +267,7 @@ WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress)( __drv_maxIRQL(DISPATCH_LEVEL) PHYSICAL_ADDRESS +STDCALL WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -283,6 +287,7 @@ WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress)( __drv_maxIRQL(DISPATCH_LEVEL) size_t +STDCALL WDFEXPORT(WdfCommonBufferGetLength)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenabler.cpp b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenabler.cpp index 91f9bdc1a85..a70c49c80e1 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenabler.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenabler.cpp @@ -21,10 +21,10 @@ Revision History: --*/ -#include "FxDmaPCH.hpp" +#include "fxdmapch.hpp" extern "C" { -#include "FxDmaEnabler.tmh" +// #include "FxDmaEnabler.tmh" } FxDmaEnabler::FxDmaEnabler( diff --git a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenablerapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenablerapi.cpp index 5b75da357b0..910f805ce89 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenablerapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenablerapi.cpp @@ -21,10 +21,10 @@ Revision History: --*/ -#include "FxDmaPCH.hpp" +#include "fxdmapch.hpp" extern "C" { -#include "FxDmaEnablerAPI.tmh" +// #include "FxDmaEnablerAPI.tmh" } // diff --git a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmapch.hpp b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmapch.hpp index d95589fbeab..06b8a061e0f 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmapch.hpp +++ b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmapch.hpp @@ -4,4 +4,4 @@ extern "C" { #include } -#include +#include diff --git a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransaction.cpp b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransaction.cpp index 38ee50b51dc..a3956e3a3e3 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransaction.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransaction.cpp @@ -21,10 +21,10 @@ Revision History: --*/ -#include "FxDmaPCH.hpp" +#include "fxdmapch.hpp" extern "C" { -#include "FxDmaTransaction.tmh" +// #include "FxDmaTransaction.tmh" } FxDmaTransactionBase::FxDmaTransactionBase( @@ -842,7 +842,7 @@ FxDmaScatterGatherTransaction::Dispose( { BOOLEAN ret; - ret = __super::Dispose(); + ret = FxDmaTransactionBase::Dispose(); // __super call // // Free Lookaside Buffer which held SGList diff --git a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransactionapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransactionapi.cpp index 7eff523e702..15864b2c485 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransactionapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransactionapi.cpp @@ -21,10 +21,10 @@ Revision History: --*/ -#include "FxDmaPCH.hpp" +#include "fxdmapch.hpp" extern "C" { -#include "FxDmaTransactionAPI.tmh" +// #include "FxDmaTransactionAPI.tmh" } // diff --git a/sdk/lib/drivers/wdf/kmdf/src/dynamic/version/version.cpp b/sdk/lib/drivers/wdf/kmdf/src/dynamic/version/version.cpp index 73a03befd65..d639d022009 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/dynamic/version/version.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/dynamic/version/version.cpp @@ -44,7 +44,7 @@ extern "C" { // available in public symbols. Various WDFKD debug commands use these // internal structures to provide information about WDF. //----------------------------------------------------------------------------- -#include "FxIFR.h" +#include "fxifr.h" extern "C" { @@ -78,9 +78,9 @@ union { extern "C" { -#include "FxDynamics.h" +#include "fxdynamics.h" -#include "FxLibraryCommon.h" +#include "fxlibrarycommon.h" #define KMDF_DEFAULT_NAME "Wdf" ## \ LITERAL(__WDF_MAJOR_VERSION_STRING) ## \ diff --git a/sdk/lib/drivers/wdf/kmdf/src/fxtosharedinterface/fxobject/fxobjectinfokm.cpp b/sdk/lib/drivers/wdf/kmdf/src/fxtosharedinterface/fxobject/fxobjectinfokm.cpp index bc1a90afbfb..ae171f80cc8 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/fxtosharedinterface/fxobject/fxobjectinfokm.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/fxtosharedinterface/fxobject/fxobjectinfokm.cpp @@ -27,11 +27,11 @@ Revision History: #include "fxobjectpch.hpp" -#include "FxMemoryBufferPreallocated.hpp" -#include "FxUserObject.hpp" -#include "FxUsbDevice.hpp" -#include "FxUsbPipe.hpp" -#include "FxUsbInterface.hpp" +#include "fxmemorybufferpreallocated.hpp" +#include "fxuserobject.hpp" +#include "fxusbdevice.hpp" +#include "fxusbpipe.hpp" +#include "fxusbinterface.hpp" extern "C" { diff --git a/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiapi.cpp index 566249d2cf1..111a57a781d 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiapi.cpp @@ -31,7 +31,7 @@ Revision History: // Extern "C" the tmh file and all external APIs // extern "C" { -#include "FxWmiAPI.tmh" +#include "fxwmiapi.tmh" _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) diff --git a/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiinstance.cpp b/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiinstance.cpp index 2c79fe9a214..ce03197299e 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiinstance.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiinstance.cpp @@ -22,7 +22,7 @@ Revision History: #include "fxwmipch.hpp" extern "C" { -#include "FxWmiInstance.tmh" +// #include "FxWmiInstance.tmh" } FxWmiInstance::FxWmiInstance( @@ -56,7 +56,7 @@ FxWmiInstance::Dispose( // of instances. If we don't do this, the provider will have a list which // contains entries which have been freed. // - return __super::Dispose(); + return FxNonPagedObject::Dispose(); // __super call } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp b/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp index 02d00aec89d..835e13ab05c 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp @@ -25,7 +25,7 @@ Revision History: #include "fxwmipch.hpp" extern "C" { -#include "FxWmiIrpHandler.tmh" +// #include "FxWmiIrpHandler.tmh" } #ifndef WppDebug diff --git a/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiprovider.cpp b/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiprovider.cpp index a542c2d3dea..2034f3bb589 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiprovider.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiprovider.cpp @@ -22,7 +22,7 @@ Revision History: #include "fxwmipch.hpp" extern "C" { -#include "FxWmiProvider.tmh" +// #include "FxWmiProvider.tmh" } FxWmiProvider::FxWmiProvider( @@ -80,7 +80,7 @@ FxWmiProvider::Dispose( // m_Parent->RemoveProvider(this); - return __super::Dispose(); + return FxNonPagedObject::Dispose(); // __super call } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/kmdf/src/librarycommon/fxlibrarycommon.cpp b/sdk/lib/drivers/wdf/kmdf/src/librarycommon/fxlibrarycommon.cpp index 6fe2cd2e886..d1824923320 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/librarycommon/fxlibrarycommon.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/librarycommon/fxlibrarycommon.cpp @@ -19,9 +19,9 @@ extern "C" { #include "fx.hpp" #include "fxldr.h" -#include "FxLibraryCommon.h" -#include "FxTelemetry.hpp" -#include "WdfVersionLog.h" +#include "fxlibrarycommon.h" +#include "fxtelemetry.hpp" +#include "wdfversionlog.h" #include "minwindef.h" extern "C" { diff --git a/sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterface.cpp b/sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterface.cpp index 2b6a6f8f2f7..cfc527b008e 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterface.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterface.cpp @@ -22,10 +22,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxQueryInterface.tmh" +// #include "FxQueryInterface.tmh" } FxQueryInterface::FxQueryInterface( diff --git a/sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterfaceapi.cpp b/sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterfaceapi.cpp index 183a33ccc4f..6d1fe7cb561 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterfaceapi.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterfaceapi.cpp @@ -22,10 +22,10 @@ Environment: Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxQueryInterfaceAPI.tmh" +// #include "FxQueryInterfaceAPI.tmh" } // @@ -35,6 +35,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAddQueryInterface)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/kmdf/src/support/fxrelateddevice.cpp b/sdk/lib/drivers/wdf/kmdf/src/support/fxrelateddevice.cpp index fb93c1ca397..5425bd11b66 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/support/fxrelateddevice.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/support/fxrelateddevice.cpp @@ -23,7 +23,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" FxRelatedDevice::FxRelatedDevice( __in PDEVICE_OBJECT DeviceObject, diff --git a/sdk/lib/drivers/wdf/kmdf/src/support/fxrelateddevicelist.cpp b/sdk/lib/drivers/wdf/kmdf/src/support/fxrelateddevicelist.cpp index 80be7033b3c..f5c50e1c5ab 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/support/fxrelateddevicelist.cpp +++ b/sdk/lib/drivers/wdf/kmdf/src/support/fxrelateddevicelist.cpp @@ -22,7 +22,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" _Must_inspect_result_ NTSTATUS @@ -111,7 +111,7 @@ FxRelatedDeviceList::ProcessAdd( } pEntry = NULL; - while ((pEntry = __super::GetNextEntryLocked(pEntry)) != NULL) { + while ((pEntry = FxSpinLockTransactionedList::GetNextEntryLocked(pEntry)) != NULL) { // __super call pInList = CONTAINING_RECORD(pEntry, FxRelatedDevice, m_TransactionedEntry); if (pInList->m_DeviceObject == pNew->m_DeviceObject) { diff --git a/sdk/lib/drivers/wdf/kmdf/src/support/probeandlock.c b/sdk/lib/drivers/wdf/kmdf/src/support/probeandlock.c index bf4ab8caaca..fec6b5e0906 100644 --- a/sdk/lib/drivers/wdf/kmdf/src/support/probeandlock.c +++ b/sdk/lib/drivers/wdf/kmdf/src/support/probeandlock.c @@ -30,6 +30,7 @@ Revision History: // #include +#include // __REACTOS__ NTSTATUS FxProbeAndLockForRead( @@ -37,11 +38,15 @@ FxProbeAndLockForRead( __in KPROCESSOR_MODE AccessMode ) { - try { + _SEH2_TRY + { MmProbeAndLockPages(Mdl, AccessMode, IoReadAccess); - } except(EXCEPTION_EXECUTE_HANDLER) { - return GetExceptionCode(); } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + _SEH2_YIELD(return _SEH2_GetExceptionCode()); + } + _SEH2_END; return STATUS_SUCCESS; } @@ -52,11 +57,16 @@ FxProbeAndLockForWrite( __in KPROCESSOR_MODE AccessMode ) { - try { + _SEH2_TRY + { MmProbeAndLockPages(Mdl, AccessMode, IoWriteAccess); - } except(EXCEPTION_EXECUTE_HANDLER) { - return GetExceptionCode(); } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + _SEH2_YIELD(return _SEH2_GetExceptionCode()); + } + _SEH2_END; + return STATUS_SUCCESS; } @@ -67,13 +77,15 @@ FxProbeAndLockWithAccess( __in LOCK_OPERATION Operation ) { - try { + _SEH2_TRY + { MmProbeAndLockPages(Mdl, AccessMode, Operation); - } except(EXCEPTION_EXECUTE_HANDLER) { - return GetExceptionCode(); } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + _SEH2_YIELD(return _SEH2_GetExceptionCode()); + } + _SEH2_END; return STATUS_SUCCESS; } - - diff --git a/sdk/lib/drivers/wdf/reactos_special.cpp b/sdk/lib/drivers/wdf/reactos_special.cpp new file mode 100644 index 00000000000..394e0720865 --- /dev/null +++ b/sdk/lib/drivers/wdf/reactos_special.cpp @@ -0,0 +1,72 @@ +#include +#include +#include +#include +#include + +extern "C" { +#include +#include +} + +#define FX_DYNAMICS_GENERATE_TABLE 1 + +#include "fx.hpp" + +// #include +// #include "fxbugcheck.h" + + +//----------------------------------------- ------------------------------------ + +extern "C" { + +#include "fxdynamics.h" + +// #include "FxLibraryCommon.h" + +typedef VOID (*WDFFUNC) (VOID); + +const WDFFUNC *WdfFunctions_01017 = (WDFFUNC *)(&WdfVersion.Functions); +// DECLSPEC_ALIGN(MAX_NATURAL_ALIGNMENT) UINT8 WdfDriverGlobalsVal[248] = { 0 }; // sizeof(FX_DRIVER_GLOBALS) +// PWDF_DRIVER_GLOBALS WdfDriverGlobals = &((PFX_DRIVER_GLOBALS)&WdfDriverGlobalsVal)->Public; +WDF_BIND_INFO WdfBindInfo = {0}; +PWDF_DRIVER_GLOBALS WdfDriverGlobals; + +#define KMDF_DEFAULT_NAME "Wdf01000" + +PCHAR WdfLdrType = KMDF_DEFAULT_NAME; + +WDFAPI +NTSTATUS +STDCALL +WdfApiNotImplemented() +{ + DbgPrint("ReactOS KMDF: %s non-implemented API called\n"); + __debugbreak(); + return STATUS_UNSUCCESSFUL; +} + +// called in WdfDriverCreate in fxdriverapi.cpp +VOID +RosInitWdf() +{ + WdfDriverGlobals = FxAllocateDriverGlobals(); + PFX_DRIVER_GLOBALS fxDriverGlobals = GetFxDriverGlobals(WdfDriverGlobals); + + WdfBindInfo.Size = sizeof(WDF_BIND_INFO); + WdfBindInfo.Version.Major = 1; + WdfBindInfo.Version.Minor = 9; + WdfBindInfo.Version.Build = 7600; + WdfBindInfo.FuncCount = WdfVersion.FuncCount; + WdfBindInfo.FuncTable = (WDFFUNC *)(&WdfVersion.Functions); + fxDriverGlobals->WdfBindInfo = &WdfBindInfo; +} + +void +__cxa_pure_virtual() +{ + __debugbreak(); +} + +} // extern "C" \ No newline at end of file diff --git a/sdk/lib/drivers/wdf/shared/core/coreprivshared.hpp b/sdk/lib/drivers/wdf/shared/core/coreprivshared.hpp index 897bb1bd50b..f92c7e336f9 100644 --- a/sdk/lib/drivers/wdf/shared/core/coreprivshared.hpp +++ b/sdk/lib/drivers/wdf/shared/core/coreprivshared.hpp @@ -46,15 +46,15 @@ extern "C" { #include "mx.h" } -#include "FxMin.hpp" +#include "fxmin.hpp" #include "wdfmemory.h" #include "wdfrequest.h" #include "wdfdevice.h" -#include "wdfdevicepri.h" -#include "wdfiotargetpri.h" +// #include "wdfdevicepri.h" +// #include "wdfiotargetpri.h" #include "wdfwmi.h" -#include "wdfChildList.h" +#include "wdfchildlist.h" #include "wdfpdo.h" #include "wdffdo.h" #include "wdfiotarget.h" @@ -62,12 +62,12 @@ extern "C" { #include "wdfcx.h" #include "wdfio.h" #include "wdfqueryinterface.h" -#include "wdftriage.h" +// #include "wdftriage.h" #if (FX_CORE_MODE == FX_CORE_USER_MODE) -#include "FxIrpUm.hpp" +#include "fxirpum.hpp" #else -#include "FxIrpKm.hpp" +#include "fxirpkm.hpp" #endif // @@ -77,92 +77,92 @@ VOID IN PVOID Parameter ); -#include "FxIrpQueue.hpp" +#include "fxirpqueue.hpp" // -#include "FxProbeAndLock.h" -#include "FxPackage.hpp" -#include "FxCollection.hpp" -#include "FxDeviceInitShared.hpp" +#include "fxprobeandlock.h" +#include "fxpackage.hpp" +#include "fxcollection.hpp" +#include "fxdeviceinitshared.hpp" -#include "IfxMemory.hpp" -#include "FxCallback.hpp" -#include "FxRequestContext.hpp" -#include "FxRequestContextTypes.h" -#include "FxRequestBase.hpp" -#include "FxMemoryObject.hpp" -#include "FxMemoryBuffer.hpp" +#include "ifxmemory.hpp" +#include "fxcallback.hpp" +#include "fxrequestcontext.hpp" +#include "fxrequestcontexttypes.h" +#include "fxrequestbase.hpp" +#include "fxmemoryobject.hpp" +#include "fxmemorybuffer.hpp" -#include "FxMemoryBufferFromPool.hpp" +#include "fxmemorybufferfrompool.hpp" -#include "FxMemoryBufferPreallocated.hpp" +#include "fxmemorybufferpreallocated.hpp" -#include "FxTransactionedList.hpp" +#include "fxtransactionedlist.hpp" // // MERGE temp: We may not need these include files here, // temporarily including them to verify they compile in shared code // -#include "FxRequestValidateFunctions.hpp" -#include "FxRequestCallbacks.hpp" +#include "fxrequestvalidatefunctions.hpp" +#include "fxrequestcallbacks.hpp" // support -#include "StringUtil.hpp" -#include "FxAutoString.hpp" -#include "FxString.hpp" -#include "FxDeviceText.hpp" -#include "FxCallback.hpp" -#include "FxDisposeList.hpp" -#include "FxSystemThread.hpp" +#include "stringutil.hpp" +#include "fxautostring.hpp" +#include "fxstring.hpp" +#include "fxdevicetext.hpp" +#include "fxcallback.hpp" +#include "fxdisposelist.hpp" +#include "fxsystemthread.hpp" -#include "FxIrpPreprocessInfo.hpp" -#include "FxPnpCallbacks.hpp" +#include "fxirppreprocessinfo.hpp" +#include "fxpnpcallbacks.hpp" // device init -#include "FxCxDeviceInit.hpp" -#include "FxCxDeviceInfo.hpp" -#include "FxDeviceInit.hpp" +#include "fxcxdeviceinit.hpp" +#include "fxcxdeviceinfo.hpp" +#include "fxdeviceinit.hpp" -#include "FxDeviceToMxInterface.hpp" +#include "fxdevicetomxinterface.hpp" // request -#include "FxRequestMemory.hpp" -#include "FxRequest.hpp" -#include "FxRequestBuffer.hpp" -#include "FxSyncRequest.hpp" +#include "fxrequestmemory.hpp" +#include "fxrequest.hpp" +#include "fxrequestbuffer.hpp" +#include "fxsyncrequest.hpp" // io target -#include "FxIoTarget.hpp" -#include "FxIoTargetSelf.hpp" +#include "fxiotarget.hpp" +#include "fxiotargetself.hpp" -#include "FxSystemWorkItem.hpp" -#include "FxCallbackMutexLock.hpp" -#include "FxDriver.hpp" +#include "fxsystemworkitem.hpp" +#include "fxcallbackmutexlock.hpp" +#include "fxdriver.hpp" -#include "FxDeviceInterface.hpp" -#include "FxQueryInterface.hpp" +#include "fxdeviceinterface.hpp" +#include "fxqueryinterface.hpp" -#include "FxCallbackSpinLock.hpp" -#include "FxDefaultIrpHandler.hpp" -#include "FxWmiIrpHandler.hpp" +#include "fxcallbackspinlock.hpp" +#include "fxdefaultirphandler.hpp" +#include "fxwmiirphandler.hpp" // packages -#include "FxPkgIo.hpp" -#include "FxPkgPnp.hpp" -#include "FxPkgFdo.hpp" -#include "FxPkgPdo.hpp" -#include "FxPkgGeneral.hpp" -#include "FxFileObject.hpp" -#include "FxIoQueue.hpp" -#include "FxDevice.hpp" -#include "FxTelemetry.hpp" +#include "fxpkgio.hpp" +#include "fxpkgpnp.hpp" +#include "fxpkgfdo.hpp" +#include "fxpkgpdo.hpp" +#include "fxpkggeneral.hpp" +#include "fxfileobject.hpp" +#include "fxioqueue.hpp" +#include "fxdevice.hpp" +#include "fxtelemetry.hpp" -#include "FxChildList.hpp" +#include "fxchildlist.hpp" -#include "FxLookasideList.hpp" +#include "fxlookasidelist.hpp" /*#if FX_IS_KERNEL_MODE #include "wdfrequest.h" diff --git a/sdk/lib/drivers/wdf/shared/core/fxcxdeviceinit.cpp b/sdk/lib/drivers/wdf/shared/core/fxcxdeviceinit.cpp index 5fbd10d660f..29845ad98a6 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxcxdeviceinit.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxcxdeviceinit.cpp @@ -26,7 +26,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxCxDeviceInit.tmh" +// #include "FxCxDeviceInit.tmh" } WDFCXDEVICE_INIT::WDFCXDEVICE_INIT() diff --git a/sdk/lib/drivers/wdf/shared/core/fxcxdeviceinitapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxcxdeviceinitapi.cpp index ecc9d93c460..571b9d82103 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxcxdeviceinitapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxcxdeviceinitapi.cpp @@ -28,7 +28,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxCxDeviceInitApi.tmh" +// #include "FxCxDeviceInitApi.tmh" } // diff --git a/sdk/lib/drivers/wdf/shared/core/fxdevice.cpp b/sdk/lib/drivers/wdf/shared/core/fxdevice.cpp index be5739a1008..6fb8723283f 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdevice.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdevice.cpp @@ -25,7 +25,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxDevice.tmh" +// #include "FxDevice.tmh" } // @@ -681,14 +681,12 @@ Return Value: PFX_DRIVER_GLOBALS pGlobals; PLIST_ENTRY next; NTSTATUS status; - BOOLEAN wmiTracing; size_t reqCtxSize; PWDFCXDEVICE_INIT cxInit; CCHAR cxIndex; FxCxDeviceInfo* cxDeviceInfo; pGlobals = GetDriverGlobals(); - wmiTracing = FALSE; m_Exclusive = DeviceInit->Exclusive; cxIndex = 0; @@ -832,11 +830,11 @@ Return Value: - m_PkgWmi = new(pGlobals) FxWmiIrpHandler(pGlobals, this); - if (m_PkgWmi == NULL) { - return STATUS_INSUFFICIENT_RESOURCES; - } - InstallPackage(m_PkgWmi); + // m_PkgWmi = new(pGlobals) FxWmiIrpHandler(pGlobals, this); __REACTOS__ + // if (m_PkgWmi == NULL) { + // return STATUS_INSUFFICIENT_RESOURCES; + // } + // InstallPackage(m_PkgWmi); #endif // @@ -1019,7 +1017,8 @@ FxDevice::CreateDevice( // administrator complete control over the device. No other users // may access the device. // - pSddl = (PUNICODE_STRING) &SDDL_DEVOBJ_SYS_ALL_ADM_ALL; + // pSddl = (PUNICODE_STRING) &SDDL_DEVOBJ_SYS_ALL_ADM_ALL; + pSddl = NULL; // __REACTOS__ : wdmsec.lib is not supported } status = Mx::MxCreateDeviceSecure( @@ -1217,7 +1216,7 @@ Return Value: // we delete the device object, otherwise we can bugcheck when // running under driver verifier. // - m_PkgWmi->Deregister(); + // m_PkgWmi->Deregister(); __REACTOS__ } // @@ -1236,7 +1235,7 @@ Return Value: } } - __super::DeleteObject(); + FxDeviceBase::DeleteObject(); // __super call } BOOLEAN @@ -1262,7 +1261,7 @@ FxDevice::Dispose( // valid to reference the pointer because there is an explicit // reference on the object that was taken when we created this object. // - m_PkgWmi->Deregister(); + // m_PkgWmi->Deregister(); __REACTOS__ } // @@ -1289,7 +1288,7 @@ FxDevice::Dispose( return FALSE; } - return __super::Dispose(); + return FxDeviceBase::Dispose(); // __super call } _Must_inspect_result_ @@ -1456,7 +1455,6 @@ PreprocessIrp( ) { NTSTATUS status; - MdDeviceObject devObj; UCHAR major, minor; FxIrp irp(Irp); @@ -1468,7 +1466,6 @@ PreprocessIrp( // EvtDevicePreprocess returns. To not touch freed pool, capture all // values we will need before preprocessing. // - devObj = Device->GetDeviceObject(); if (Info->ClassExtension == FALSE) { status = Info->Dispatch[major].EvtDevicePreprocess( Device->GetHandle(), @@ -1518,7 +1515,7 @@ DispatchWorker( next = (PLIST_ENTRY)DispatchContext; ASSERT(NULL != DispatchContext && - ((UCHAR)DispatchContext & FX_IN_DISPATCH_CALLBACK) == 0); + ((UCHAR)(ULONG_PTR)DispatchContext & FX_IN_DISPATCH_CALLBACK) == 0); // // Check for any driver/class-extensions' preprocess requirements. @@ -1762,7 +1759,7 @@ FxDevice::QueryInterface( break; default: - return __super::QueryInterface(Params); + return FxDeviceBase::QueryInterface(Params); // __super call } return STATUS_SUCCESS; diff --git a/sdk/lib/drivers/wdf/shared/core/fxdeviceapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxdeviceapi.cpp index b057ed4ae38..26b3ef07c78 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdeviceapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdeviceapi.cpp @@ -26,7 +26,7 @@ Revision History: #include "fxiotarget.hpp" extern "C" { -#include "FxDeviceApi.tmh" +// #include "FxDeviceApi.tmh" } struct FxOffsetAndName { @@ -43,6 +43,7 @@ extern "C" { __drv_maxIRQL(DISPATCH_LEVEL) WDFDRIVER +STDCALL WDFEXPORT(WdfDeviceGetDriver)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -83,6 +84,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) WDFIOTARGET +STDCALL WDFEXPORT(WdfDeviceGetIoTarget)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -111,6 +113,7 @@ WDFEXPORT(WdfDeviceGetIoTarget)( _IRQL_requires_max_(DISPATCH_LEVEL) WDFIOTARGET +STDCALL WDFEXPORT(WdfDeviceGetSelfIoTarget)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -160,6 +163,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceRetrieveDeviceName)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -208,6 +212,7 @@ WDFEXPORT(WdfDeviceRetrieveDeviceName)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetCharacteristics)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -234,6 +239,7 @@ WDFEXPORT(WdfDeviceSetCharacteristics)( __drv_maxIRQL(DISPATCH_LEVEL) ULONG +STDCALL WDFEXPORT(WdfDeviceGetCharacteristics)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -258,6 +264,7 @@ WDFEXPORT(WdfDeviceGetCharacteristics)( __drv_maxIRQL(DISPATCH_LEVEL) ULONG +STDCALL WDFEXPORT(WdfDeviceGetAlignmentRequirement)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -282,6 +289,7 @@ WDFEXPORT(WdfDeviceGetAlignmentRequirement)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetAlignmentRequirement)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -308,6 +316,7 @@ WDFEXPORT(WdfDeviceSetAlignmentRequirement)( __drv_maxIRQL(DISPATCH_LEVEL) WDF_DEVICE_PNP_STATE +STDCALL WDFEXPORT(WdfDeviceGetDevicePnpState)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -329,6 +338,7 @@ WDFEXPORT(WdfDeviceGetDevicePnpState)( __drv_maxIRQL(DISPATCH_LEVEL) WDF_DEVICE_POWER_STATE +STDCALL WDFEXPORT(WdfDeviceGetDevicePowerState)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -350,6 +360,7 @@ WDFEXPORT(WdfDeviceGetDevicePowerState)( __drv_maxIRQL(DISPATCH_LEVEL) WDF_DEVICE_POWER_POLICY_STATE +STDCALL WDFEXPORT(WdfDeviceGetDevicePowerPolicyState)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -372,6 +383,7 @@ WDFEXPORT(WdfDeviceGetDevicePowerPolicyState)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAssignS0IdleSettings)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -484,6 +496,7 @@ WDFEXPORT(WdfDeviceAssignS0IdleSettings)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAssignSxWakeSettings)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -579,6 +592,7 @@ WDFEXPORT(WdfDeviceAssignSxWakeSettings)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceOpenRegistryKey)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -635,6 +649,7 @@ WDFEXPORT(WdfDeviceOpenRegistryKey)( _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceOpenDevicemapKey) ( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -727,6 +742,7 @@ WDFEXPORT(WdfDeviceOpenDevicemapKey) ( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceGetDeviceState)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -765,6 +781,7 @@ WDFEXPORT(WdfDeviceGetDeviceState)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetDeviceState)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -846,6 +863,7 @@ WDFEXPORT(WdfDeviceSetDeviceState)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -957,6 +975,7 @@ WDFEXPORT(WdfDeviceCreate)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceCreateSymbolicLink)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -969,7 +988,6 @@ WDFEXPORT(WdfDeviceCreateSymbolicLink)( DDI_ENTRY(); PFX_DRIVER_GLOBALS pFxDriverGlobals; - PUNICODE_STRING pName; FxAutoString pdoName; FxDevice* pDevice; NTSTATUS status; @@ -979,7 +997,6 @@ WDFEXPORT(WdfDeviceCreateSymbolicLink)( FX_TYPE_DEVICE, (PVOID *) &pDevice, &pFxDriverGlobals); - pName = NULL; FxPointerNotNull(pFxDriverGlobals, SymbolicLinkName); @@ -1022,6 +1039,7 @@ WDFEXPORT(WdfDeviceCreateSymbolicLink)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceQueryProperty)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1109,6 +1127,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAllocAndQueryProperty)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1201,6 +1220,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetStaticStopRemove)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1237,6 +1257,7 @@ WDFEXPORT(WdfDeviceSetStaticStopRemove)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetFailed)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1368,6 +1389,7 @@ _Must_inspect_result_ __drv_when(WaitForD0 == 0, __drv_maxIRQL(DISPATCH_LEVEL)) __drv_when(WaitForD0 != 0, __drv_maxIRQL(PASSIVE_LEVEL)) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceStopIdleNoTrack)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1395,6 +1417,7 @@ _Must_inspect_result_ __drv_when(WaitForD0 == 0, __drv_maxIRQL(DISPATCH_LEVEL)) __drv_when(WaitForD0 != 0, __drv_maxIRQL(PASSIVE_LEVEL)) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceStopIdleActual)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1426,6 +1449,7 @@ WDFEXPORT(WdfDeviceStopIdleActual)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceResumeIdleNoTrack)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1444,6 +1468,7 @@ WDFEXPORT(WdfDeviceResumeIdleNoTrack)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceResumeIdleActual)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1468,6 +1493,7 @@ WDFEXPORT(WdfDeviceResumeIdleActual)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetPnpCapabilities)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1565,6 +1591,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetPowerCapabilities)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1734,6 +1761,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceConfigureRequestDispatching)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1865,6 +1893,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) WDFQUEUE +STDCALL WDFEXPORT(WdfDeviceGetDefaultQueue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1927,6 +1956,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceEnqueueRequest)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2002,6 +2032,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) POWER_ACTION +STDCALL WDFEXPORT(WdfDeviceGetSystemPowerAction)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2055,6 +2086,7 @@ _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceQueryPropertyEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2186,6 +2218,7 @@ _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAllocAndQueryPropertyEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2303,6 +2336,7 @@ _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAssignProperty)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2408,6 +2442,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceConfigureWdmIrpDispatchCallback)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxdevicebase.cpp b/sdk/lib/drivers/wdf/shared/core/fxdevicebase.cpp index 63327fd6888..734f2f9ab29 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdevicebase.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdevicebase.cpp @@ -25,7 +25,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxDeviceBase.tmh" +// #include "FxDeviceBase.tmh" } FxDeviceBase::FxDeviceBase( @@ -83,7 +83,7 @@ FxDeviceBase::QueryInterface( break; default: - return __super::QueryInterface(Params); + return FxNonPagedObject::QueryInterface(Params); // __super call } return STATUS_SUCCESS; diff --git a/sdk/lib/drivers/wdf/shared/core/fxdevicecontrolapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxdevicecontrolapi.cpp index 54450c19f7f..9845ebcba55 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdevicecontrolapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdevicecontrolapi.cpp @@ -25,13 +25,14 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxDeviceControlAPI.tmh" +// #include "FxDeviceControlAPI.tmh" } extern "C" { __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfControlFinishInitializing)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -51,7 +52,7 @@ WDFEXPORT(WdfControlFinishInitializing)( MxDeviceObject device(pDevice->GetDeviceObject()); if (pDevice->IsLegacy()) { - pDevice->m_PkgWmi->Register(); + // pDevice->m_PkgWmi->Register(); __REACTOS__ device.SetFlags(device.GetFlags() & ~DO_DEVICE_INITIALIZING); } else { diff --git a/sdk/lib/drivers/wdf/shared/core/fxdeviceinit.cpp b/sdk/lib/drivers/wdf/shared/core/fxdeviceinit.cpp index 3d84e3488af..5e10d82cc54 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdeviceinit.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdeviceinit.cpp @@ -24,7 +24,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxDeviceInit.tmh" +// #include "FxDeviceInit.tmh" } WDFDEVICE_INIT::WDFDEVICE_INIT( diff --git a/sdk/lib/drivers/wdf/shared/core/fxdeviceinitapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxdeviceinitapi.cpp index 02588d42775..4adc45b5f26 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdeviceinitapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdeviceinitapi.cpp @@ -25,7 +25,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxDeviceInitApi.tmh" +// #include "FxDeviceInitApi.tmh" } typedef struct _WDF_PNPPOWER_EVENT_CALLBACKS_V1_9 { @@ -137,6 +137,7 @@ extern "C" { __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitFree)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -155,6 +156,7 @@ WDFEXPORT(WdfDeviceInitFree)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetIoType)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -179,6 +181,7 @@ WDFEXPORT(WdfDeviceInitSetIoType)( _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfDeviceInitSetIoTypeEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -211,6 +214,7 @@ WDFEXPORT(WdfDeviceInitSetIoTypeEx)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetExclusive)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -229,6 +233,7 @@ WDFEXPORT(WdfDeviceInitSetExclusive)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetDeviceType)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -247,6 +252,7 @@ WDFEXPORT(WdfDeviceInitSetDeviceType)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerNotPageable)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -263,6 +269,7 @@ WDFEXPORT(WdfDeviceInitSetPowerNotPageable)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerPageable)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -279,6 +286,7 @@ WDFEXPORT(WdfDeviceInitSetPowerPageable)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerInrush)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -300,6 +308,7 @@ WDFEXPORT(WdfDeviceInitSetPowerInrush)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitAssignName)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -351,6 +360,7 @@ WDFEXPORT(WdfDeviceInitAssignName)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetCharacteristics)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -385,6 +395,7 @@ WDFEXPORT(WdfDeviceInitSetCharacteristics)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetFileObjectConfig)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -555,6 +566,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetRequestAttributes)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -595,6 +607,7 @@ WDFEXPORT(WdfDeviceInitSetRequestAttributes)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitAssignSDDLString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -659,6 +672,7 @@ WDFEXPORT(WdfDeviceInitAssignSDDLString)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetDeviceClass)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -685,6 +699,7 @@ WDFEXPORT(WdfDeviceInitSetDeviceClass)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPnpPowerEventCallbacks)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -748,6 +763,7 @@ WDFEXPORT(WdfDeviceInitSetPnpPowerEventCallbacks)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerPolicyEventCallbacks)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -809,6 +825,7 @@ WDFEXPORT(WdfDeviceInitSetPowerPolicyEventCallbacks)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetPowerPolicyOwnership)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -828,6 +845,7 @@ WDFEXPORT(WdfDeviceInitSetPowerPolicyOwnership)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitRegisterPnpStateChangeCallback)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -907,6 +925,7 @@ WDFEXPORT(WdfDeviceInitRegisterPnpStateChangeCallback)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitRegisterPowerStateChangeCallback)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -987,6 +1006,7 @@ WDFEXPORT(WdfDeviceInitRegisterPowerStateChangeCallback)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitRegisterPowerPolicyStateChangeCallback)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1068,6 +1088,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfDeviceInitAssignWdmIrpPreprocessCallback)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1168,6 +1189,7 @@ WDFEXPORT(WdfDeviceInitAssignWdmIrpPreprocessCallback)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetIoInCallerContextCallback)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1222,6 +1244,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetRemoveLockOptions)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1287,6 +1310,7 @@ Done: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitSetReleaseHardwareOrderOnFailure)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1317,6 +1341,7 @@ WDFEXPORT(WdfDeviceInitSetReleaseHardwareOrderOnFailure)( _IRQL_requires_max_(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceInitAllowSelfIoTarget)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1358,6 +1383,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfFdoInitWdmGetPhysicalDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1384,6 +1410,7 @@ WDFEXPORT(WdfFdoInitWdmGetPhysicalDevice)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitOpenRegistryKey)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1435,6 +1462,7 @@ WDFEXPORT(WdfFdoInitOpenRegistryKey)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfFdoInitSetFilter)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1468,6 +1496,7 @@ WDFEXPORT(WdfFdoInitSetFilter)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitQueryProperty)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1544,6 +1573,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitAllocAndQueryProperty)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1627,6 +1657,7 @@ Return Value: __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfFdoInitSetEventCallbacks)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1688,6 +1719,7 @@ WDFEXPORT(WdfFdoInitSetEventCallbacks)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfFdoInitSetDefaultChildListConfig)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1754,6 +1786,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitQueryPropertyEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1871,6 +1904,7 @@ _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfFdoInitAllocAndQueryPropertyEx)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1995,6 +2029,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) PWDFDEVICE_INIT +STDCALL WDFEXPORT(WdfPdoInitAllocate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2050,6 +2085,7 @@ WDFEXPORT(WdfPdoInitAllocate)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfPdoInitSetEventCallbacks)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2096,6 +2132,7 @@ WDFEXPORT(WdfPdoInitSetEventCallbacks)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAssignDeviceID)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2154,6 +2191,7 @@ WDFEXPORT(WdfPdoInitAssignDeviceID)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAssignInstanceID)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2212,6 +2250,7 @@ WDFEXPORT(WdfPdoInitAssignInstanceID)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAddHardwareID)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2277,6 +2316,7 @@ WDFEXPORT(WdfPdoInitAddHardwareID)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAddCompatibleID)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2342,6 +2382,7 @@ WDFEXPORT(WdfPdoInitAddCompatibleID)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAssignContainerID)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2402,6 +2443,7 @@ WDFEXPORT(WdfPdoInitAssignContainerID)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAddDeviceText)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2505,6 +2547,7 @@ Done: __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfPdoInitSetDefaultLocale)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2540,6 +2583,7 @@ WDFEXPORT(WdfPdoInitSetDefaultLocale)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfPdoInitAssignRawDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2583,6 +2627,7 @@ WDFEXPORT(WdfPdoInitAssignRawDevice)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfPdoInitAllowForwardingRequestToParent)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2628,6 +2673,7 @@ WDFEXPORT(WdfPdoInitAllowForwardingRequestToParent)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) PWDFDEVICE_INIT +STDCALL WDFEXPORT(WdfControlDeviceInitAllocate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2666,6 +2712,7 @@ WDFEXPORT(WdfControlDeviceInitAllocate)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfControlDeviceInitSetShutdownNotification)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxdisposelist.cpp b/sdk/lib/drivers/wdf/shared/core/fxdisposelist.cpp index c1443cae701..05e1cdebdca 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdisposelist.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdisposelist.cpp @@ -31,11 +31,11 @@ Revision History: #include "coreprivshared.hpp" -#include "FxDisposeList.hpp" +#include "fxdisposelist.hpp" // Tracing support extern "C" { -#include "FxDisposeList.tmh" +// #include "FxDisposeList.tmh" } FxDisposeList::FxDisposeList( @@ -121,7 +121,7 @@ FxDisposeList::Dispose( ASSERT(m_List.Next == NULL); - __super::Dispose(); + FxNonPagedObject::Dispose(); // __super call return TRUE; } diff --git a/sdk/lib/drivers/wdf/shared/core/fxdriver.cpp b/sdk/lib/drivers/wdf/shared/core/fxdriver.cpp index 1dc3bc70a6e..7c3ca62c201 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdriver.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdriver.cpp @@ -27,7 +27,7 @@ Revision History: // Tracing support extern "C" { -#include "FxDriver.tmh" +// #include "FxDriver.tmh" } FxDriver::FxDriver( @@ -133,7 +133,7 @@ FxDriver::Dispose( m_DisposeList->WaitForEmpty(); } - return __super::Dispose(); + return FxNonPagedObject::Dispose(); // __super call } VOID diff --git a/sdk/lib/drivers/wdf/shared/core/fxdriverapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxdriverapi.cpp index 67243d61d31..efb2b6d79ed 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxdriverapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxdriverapi.cpp @@ -27,10 +27,10 @@ Revision History: // Tracing support extern "C" { #include -#include "FxDriverApi.tmh" +// #include "FxDriverApi.tmh" } -#include "FxTelemetry.hpp" +#include "fxtelemetry.hpp" // // extern the whole file @@ -44,6 +44,7 @@ extern "C" { __drv_maxIRQL(PASSIVE_LEVEL) PWSTR +STDCALL WDFEXPORT(WdfDriverGetRegistryPath)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -71,9 +72,13 @@ WDFEXPORT(WdfDriverGetRegistryPath)( return pDriver->GetRegistryPathUnicodeString()->Buffer; } +VOID +RosInitWdf(); + _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDriverCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -98,6 +103,9 @@ WDFEXPORT(WdfDriverCreate)( const LONG validFlags = WdfDriverInitNonPnpDriver | WdfDriverInitNoDispatchOverride; + RosInitWdf(); + DriverGlobals = WdfDriverGlobals; + hDriver = NULL; pFxDriverGlobals = GetFxDriverGlobals(DriverGlobals); @@ -302,6 +310,7 @@ WDFEXPORT(WdfDriverCreate)( *Driver = hDriver; } +#ifndef __REACTOS__ if (FX_TELEMETRY_ENABLED(g_TelemetryProvider, pFxDriverGlobals)) { FxAutoString imageName; @@ -329,6 +338,7 @@ WDFEXPORT(WdfDriverCreate)( imageName.m_UnicodeString.Buffer, pVersionStr); } +#endif // __REACTOS__ } else { if (pDriver != NULL) { @@ -344,6 +354,7 @@ WDFEXPORT(WdfDriverCreate)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDriverRegisterTraceInfo)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -368,6 +379,7 @@ WDFEXPORT(WdfDriverRegisterTraceInfo)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDriverRetrieveVersionString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -442,6 +454,7 @@ WDFEXPORT(WdfDriverRetrieveVersionString)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) BOOLEAN +STDCALL WDFEXPORT(WdfDriverIsVersionAvailable)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxfileobject.cpp b/sdk/lib/drivers/wdf/shared/core/fxfileobject.cpp index 339ddabcc24..048dbfaf99e 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxfileobject.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxfileobject.cpp @@ -27,7 +27,7 @@ Revision History: // Tracing support extern "C" { -#include "FxFileObject.tmh" +// #include "FxFileObject.tmh" } // @@ -501,7 +501,7 @@ Return Value: break; default: - return __super::QueryInterface(Params); + return FxNonPagedObject::QueryInterface(Params); // __super call } return STATUS_SUCCESS; diff --git a/sdk/lib/drivers/wdf/shared/core/fxfileobjectapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxfileobjectapi.cpp index 4589ddfbd6e..3c36b87587d 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxfileobjectapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxfileobjectapi.cpp @@ -24,10 +24,10 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxFileObject.hpp" +#include "fxfileobject.hpp" extern "C" { -#include "FxFileObjectApi.tmh" +// #include "FxFileObjectApi.tmh" } // @@ -37,6 +37,7 @@ extern "C" { __drv_maxIRQL(PASSIVE_LEVEL) PUNICODE_STRING +STDCALL WDFEXPORT(WdfFileObjectGetFileName)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -93,6 +94,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) ULONG +STDCALL WDFEXPORT(WdfFileObjectGetFlags)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -139,6 +141,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) WDFDEVICE +STDCALL WDFEXPORT(WdfFileObjectGetDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxirpqueue.cpp b/sdk/lib/drivers/wdf/shared/core/fxirpqueue.cpp index 26baa1d236f..16114ac320f 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxirpqueue.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxirpqueue.cpp @@ -32,7 +32,7 @@ Revision History: // Tracing support extern "C" { -#include "FxIrpQueue.tmh" +// #include "FxIrpQueue.tmh" } // diff --git a/sdk/lib/drivers/wdf/shared/core/fxlookasidelist.cpp b/sdk/lib/drivers/wdf/shared/core/fxlookasidelist.cpp index b5867a75d75..4b0d109cdef 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxlookasidelist.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxlookasidelist.cpp @@ -22,7 +22,7 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxLookasideList.hpp" +#include "fxlookasidelist.hpp" FxLookasideList::FxLookasideList( __in PFX_DRIVER_GLOBALS FxDriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxlookasidelistapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxlookasidelistapi.cpp index bb6b84c152e..2192a1c17b7 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxlookasidelistapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxlookasidelistapi.cpp @@ -22,11 +22,11 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxNPagedLookasideList.hpp" -#include "FxPagedLookasideList.hpp" +#include "fxnpagedlookasidelist.hpp" +#include "fxpagedlookasidelist.hpp" extern "C" { -#include "FxLookasideListAPI.tmh" +// #include "FxLookasideListAPI.tmh" } extern "C" { @@ -36,6 +36,7 @@ __drv_when(PoolType == 1 || PoolType == 257, __drv_maxIRQL(APC_LEVEL)) __drv_when(PoolType == 0 || PoolType == 256, __drv_maxIRQL(DISPATCH_LEVEL)) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfLookasideListCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -235,6 +236,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfMemoryCreateFromLookaside)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxmemorybuffer.cpp b/sdk/lib/drivers/wdf/shared/core/fxmemorybuffer.cpp index 828a19479df..8fedc0b2337 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxmemorybuffer.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxmemorybuffer.cpp @@ -21,10 +21,10 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxMemoryBuffer.hpp" +#include "fxmemorybuffer.hpp" extern "C" { -#include "FxMemoryBuffer.tmh" +// #include "FxMemoryBuffer.tmh" } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/core/fxmemorybufferapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxmemorybufferapi.cpp index 2c0fa6f6ef4..11dc632cb18 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxmemorybufferapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxmemorybufferapi.cpp @@ -22,10 +22,10 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxMemoryBuffer.hpp" +#include "fxmemorybuffer.hpp" extern "C" { -#include "FxMemoryBufferAPI.tmh" +// #include "FxMemoryBufferAPI.tmh" } extern "C" { @@ -35,6 +35,7 @@ __drv_when(PoolType == 1 || PoolType == 257, __drv_maxIRQL(APC_LEVEL)) __drv_when(PoolType == 0 || PoolType == 256, __drv_maxIRQL(DISPATCH_LEVEL)) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -164,6 +165,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) PVOID WDFAPI +STDCALL WDFEXPORT(WdfMemoryGetBuffer)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -207,6 +209,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfMemoryCopyToBuffer)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -285,6 +288,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfMemoryCopyFromBuffer)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxmemorybufferfromlookaside.cpp b/sdk/lib/drivers/wdf/shared/core/fxmemorybufferfromlookaside.cpp index 2938c42039c..33e12577544 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxmemorybufferfromlookaside.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxmemorybufferfromlookaside.cpp @@ -22,8 +22,8 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxNPagedLookasideList.hpp" -#include "FxMemoryBufferFromLookaside.hpp" +#include "fxnpagedlookasidelist.hpp" +#include "fxmemorybufferfromlookaside.hpp" FxMemoryBufferFromLookaside::FxMemoryBufferFromLookaside( __in PFX_DRIVER_GLOBALS FxDriverGlobals, @@ -215,7 +215,7 @@ Return Value: // within the destructor b/c then all parent objects would be destructing on // freed pool. // - FxMemoryBufferFromLookaside::~FxMemoryBufferFromLookaside(); + this->~FxMemoryBufferFromLookaside(); // // After FxLookaside::Reclaim, this no longer points to valid memory so we @@ -268,7 +268,7 @@ FxMemoryBufferFromPoolLookaside::SelfDestruct( // // Free the object itself // - __super::SelfDestruct(); + FxMemoryBufferFromLookaside::SelfDestruct(); // __super call } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/core/fxmemorybufferpreallocated.cpp b/sdk/lib/drivers/wdf/shared/core/fxmemorybufferpreallocated.cpp index d708a2e9a89..c566be61461 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxmemorybufferpreallocated.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxmemorybufferpreallocated.cpp @@ -21,7 +21,7 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxMemoryBufferPreallocated.hpp" +#include "fxmemorybufferpreallocated.hpp" FxMemoryBufferPreallocated::FxMemoryBufferPreallocated( _In_ PFX_DRIVER_GLOBALS FxDriverGlobals, @@ -125,7 +125,7 @@ FxMemoryBufferPreallocated::QueryInterface( return STATUS_SUCCESS; } else { - return __super::QueryInterface(Params); + return FxMemoryObject::QueryInterface(Params); // __super call } } diff --git a/sdk/lib/drivers/wdf/shared/core/fxmemorybufferpreallocatedapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxmemorybufferpreallocatedapi.cpp index 7063e4c70cf..66958b0f613 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxmemorybufferpreallocatedapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxmemorybufferpreallocatedapi.cpp @@ -22,10 +22,10 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxMemoryBufferPreallocated.hpp" +#include "fxmemorybufferpreallocated.hpp" extern "C" { -#include "FxMemoryBufferPreallocatedAPI.tmh" +// #include "FxMemoryBufferPreallocatedAPI.tmh" } extern "C" { @@ -34,6 +34,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryCreatePreallocated)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -136,6 +137,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfMemoryAssignBuffer)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxmemoryobject.cpp b/sdk/lib/drivers/wdf/shared/core/fxmemoryobject.cpp index 9625f751f3d..6d8857ac41d 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxmemoryobject.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxmemoryobject.cpp @@ -23,7 +23,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxMemoryObject.tmh" +// #include "FxMemoryObject.tmh" } FxMemoryObject::FxMemoryObject( diff --git a/sdk/lib/drivers/wdf/shared/core/fxpagedlookasidelist.cpp b/sdk/lib/drivers/wdf/shared/core/fxpagedlookasidelist.cpp index 7bd3ea1de6f..1a8058b535f 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxpagedlookasidelist.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxpagedlookasidelist.cpp @@ -23,8 +23,8 @@ Revision History: #include "coreprivshared.hpp" -#include "FxPagedLookasideList.hpp" -#include "FxMemoryBufferFromLookaside.hpp" +#include "fxpagedlookasidelist.hpp" +#include "fxmemorybufferfromlookaside.hpp" FxPagedLookasideListFromPool::FxPagedLookasideListFromPool( __in PFX_DRIVER_GLOBALS FxDriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxrequest.cpp b/sdk/lib/drivers/wdf/shared/core/fxrequest.cpp index 75f8ae583ec..aaaad7390ce 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxrequest.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxrequest.cpp @@ -27,16 +27,9 @@ Revision History: // Tracing support extern "C" { -#include "FxRequest.tmh" +// #include "FxRequest.tmh" } - - - - - -#define WDF_REQUEST_REUSE_MUST_COMPLETE 2 - FxRequest::FxRequest( __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in MdIrp Irp, @@ -1298,13 +1291,12 @@ FxRequest::GetMemoryObject( NTSTATUS status; ULONG length; KIRQL irql; - BOOLEAN mapMdl, mdlMapped; + BOOLEAN mapMdl; UCHAR majorFunction; status = STATUS_SUCCESS; length = 0x0; mapMdl = FALSE; - mdlMapped = FALSE; irql = PASSIVE_LEVEL; majorFunction = m_Irp.GetMajorFunction(); @@ -2146,7 +2138,6 @@ FxRequest::Reuse( ) { FxIrp currentIrp; - FxRequestContext* pContext; PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals(); // @@ -2177,7 +2168,6 @@ FxRequest::Reuse( SetCompletionRoutine(NULL, NULL); } - pContext = NULL; currentIrp.SetIrp(m_Irp.GetIrp()); if (currentIrp.GetIrp() != NULL) { @@ -2743,7 +2733,7 @@ FxRequest::QueryInterface( // || || Fall || || // \/ \/ through \/ \/ default: - return __super::QueryInterface(Params); + return FxRequestBase::QueryInterface(Params); // __super call } return STATUS_SUCCESS; @@ -3114,7 +3104,7 @@ FxRequest::Release( allocFromIo = IsAllocatedFromIo(); canComplete = IsCanComplete(); - retValue = __super::Release(Tag, Line, File); + retValue = FxRequestBase::Release(Tag, Line, File); // __super call if (reservedRequest && retValue == 1 && m_Completed) { // @@ -3195,7 +3185,7 @@ FxRequestFromLookaside::SelfDestruct( // // Destroy the object // - FxRequestFromLookaside::~FxRequestFromLookaside(); + // FxRequestFromLookaside::~FxRequestFromLookaside(); __REACTOS__ if (IsRequestForwardedToParent()) { diff --git a/sdk/lib/drivers/wdf/shared/core/fxrequestapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxrequestapi.cpp index f5dad9e06fb..42a36abeae1 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxrequestapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxrequestapi.cpp @@ -28,7 +28,7 @@ Revision History: // Tracing support extern "C" { -#include "FxRequestApi.tmh" +// #include "FxRequestApi.tmh" // // Verifiers @@ -64,6 +64,7 @@ VerifyWdfRequestForwardToParentDeviceIoQueue, _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -156,6 +157,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestCreateFromIrp)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -255,6 +257,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestReuse)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -326,6 +329,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestChangeTarget)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -379,6 +383,7 @@ FX_VF_FUNCTION(VerifyRequestComplete) ( __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfRequestComplete)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -439,6 +444,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfRequestCompleteWithPriorityBoost)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -507,6 +513,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfRequestCompleteWithInformation)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -574,6 +581,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfRequestSetInformation)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -630,6 +638,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) ULONG_PTR WDFAPI +STDCALL WDFEXPORT(WdfRequestGetInformation)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -673,6 +682,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestRetrieveInputMemory)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -784,6 +794,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestRetrieveOutputMemory)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -906,6 +917,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestRetrieveInputBuffer)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1049,6 +1061,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestRetrieveOutputBuffer)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1202,6 +1215,7 @@ _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestRetrieveUnsafeUserInputBuffer)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1405,6 +1419,7 @@ _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestRetrieveUnsafeUserOutputBuffer)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1606,6 +1621,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestRetrieveInputWdmMdl)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1705,6 +1721,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestRetrieveOutputWdmMdl)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1850,6 +1867,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) BOOLEAN +STDCALL WDFEXPORT(WdfRequestSend)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2104,6 +2122,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestGetStatus)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2124,6 +2143,7 @@ WDFEXPORT(WdfRequestGetStatus)( __drv_maxIRQL(DISPATCH_LEVEL) BOOLEAN WDFAPI +STDCALL WDFEXPORT(WdfRequestCancelSentRequest)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2176,6 +2196,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(APC_LEVEL) BOOLEAN +STDCALL WDFEXPORT(WdfRequestIsFrom32BitProcess)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2221,6 +2242,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfRequestFormatRequestUsingCurrentType)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2291,6 +2313,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfRequestWdmFormatUsingStackLocation)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2371,6 +2394,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfRequestSetCompletionRoutine)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2409,6 +2433,7 @@ WDFEXPORT(WdfRequestSetCompletionRoutine)( __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfRequestGetParameters)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2458,6 +2483,7 @@ WDFEXPORT(WdfRequestGetParameters)( __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfRequestGetCompletionParams)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2504,6 +2530,7 @@ WDFEXPORT(WdfRequestGetCompletionParams)( __drv_maxIRQL(DISPATCH_LEVEL) MdIrp WDFAPI +STDCALL WDFEXPORT(WdfRequestWdmGetIrp)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2568,6 +2595,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestAllocateTimer)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2610,6 +2638,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) WDFFILEOBJECT WDFAPI +STDCALL WDFEXPORT(WdfRequestGetFileObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2689,6 +2718,7 @@ _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestProbeAndLockUserBufferForRead)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2790,6 +2820,7 @@ _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfRequestProbeAndLockUserBufferForWrite)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2888,6 +2919,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) KPROCESSOR_MODE WDFAPI +STDCALL WDFEXPORT(WdfRequestGetRequestorMode)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -2930,6 +2962,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) WDFQUEUE WDFAPI +STDCALL WDFEXPORT(WdfRequestGetIoQueue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3052,6 +3085,7 @@ FX_VF_FUNCTION(VerifyWdfRequestForwardToIoQueue) ( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestForwardToIoQueue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3206,6 +3240,7 @@ Done: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestForwardToParentDeviceIoQueue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3338,6 +3373,7 @@ Done: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestRequeue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3396,6 +3432,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfRequestMarkCancelable)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3465,6 +3502,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestMarkCancelableEx)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3538,6 +3576,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRequestUnmarkCancelable)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3619,6 +3658,7 @@ FX_VF_FUNCTION(VerifyWdfRequestIsCanceled)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) BOOLEAN +STDCALL WDFEXPORT(WdfRequestIsCanceled)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3666,6 +3706,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfRequestStopAcknowledge)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -3723,6 +3764,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) BOOLEAN +STDCALL WDFEXPORT(WdfRequestIsReserved)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxrequestbase.cpp b/sdk/lib/drivers/wdf/shared/core/fxrequestbase.cpp index 134bf6a50ca..94572ac26f6 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxrequestbase.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxrequestbase.cpp @@ -26,7 +26,7 @@ Revision History: // Tracing support extern "C" { -#include "FxRequestBase.tmh" +// #include "FxRequestBase.tmh" } FxRequestBase::FxRequestBase( @@ -811,7 +811,7 @@ Return Value: return TRUE; } -__declspec(noreturn) +DECLSPEC_NORETURN VOID FxRequestBase::FatalError( __in NTSTATUS Status diff --git a/sdk/lib/drivers/wdf/shared/core/fxrequestcontext.cpp b/sdk/lib/drivers/wdf/shared/core/fxrequestcontext.cpp index 80a68d38911..7a53a2a7950 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxrequestcontext.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxrequestcontext.cpp @@ -28,7 +28,7 @@ Revision History: // Tracing support extern "C" { -#include "FxRequestContext.tmh" +// #include "FxRequestContext.tmh" } FxRequestContext::FxRequestContext( diff --git a/sdk/lib/drivers/wdf/shared/core/fxrequestmemory.cpp b/sdk/lib/drivers/wdf/shared/core/fxrequestmemory.cpp index 22bc0fc2bc9..01d2b983f99 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxrequestmemory.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxrequestmemory.cpp @@ -156,7 +156,7 @@ FxRequestMemory::QueryInterface( return STATUS_SUCCESS; } else { - return __super::QueryInterface(Params); + return FxMemoryBufferPreallocated::QueryInterface(Params); // __super call } } diff --git a/sdk/lib/drivers/wdf/shared/core/fxrequestoutputbuffer.cpp b/sdk/lib/drivers/wdf/shared/core/fxrequestoutputbuffer.cpp index f1c59c28b47..f44331c2108 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxrequestoutputbuffer.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxrequestoutputbuffer.cpp @@ -29,7 +29,7 @@ Revision History: // Tracing support extern "C" { -#include "FxRequestOutputBuffer.tmh" +// #include "FxRequestOutputBuffer.tmh" } PVOID diff --git a/sdk/lib/drivers/wdf/shared/core/fxrequestsystembuffer.cpp b/sdk/lib/drivers/wdf/shared/core/fxrequestsystembuffer.cpp index 801364cdb8f..258239f1227 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxrequestsystembuffer.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxrequestsystembuffer.cpp @@ -30,7 +30,7 @@ Revision History: // Tracing support extern "C" { -#include "FxRequestSystemBuffer.tmh" +// #include "FxRequestSystemBuffer.tmh" } size_t diff --git a/sdk/lib/drivers/wdf/shared/core/fxsyncrequest.cpp b/sdk/lib/drivers/wdf/shared/core/fxsyncrequest.cpp index b92ae4524e3..e47878d454e 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxsyncrequest.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxsyncrequest.cpp @@ -26,7 +26,7 @@ Revision History: // Tracing support extern "C" { -#include "FxSyncRequest.tmh" +// #include "FxSyncRequest.tmh" } FxSyncRequest::FxSyncRequest( @@ -126,7 +126,7 @@ Return Value: // Release the initial reference taken on create. Use the base release call // so that we don't unnecessarily set the event unless we have to. // - count = __super::RELEASE(NULL); + count = FxRequestBase::RELEASE(NULL); // __super call // // For a driver supplied request(m_TrueRequest) the request context is diff --git a/sdk/lib/drivers/wdf/shared/core/fxsystemworkitem.cpp b/sdk/lib/drivers/wdf/shared/core/fxsystemworkitem.cpp index 14f673a8392..19284406067 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxsystemworkitem.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxsystemworkitem.cpp @@ -26,11 +26,11 @@ Revision History: #include "coreprivshared.hpp" -#include "FxSystemWorkItem.hpp" +#include "fxsystemworkitem.hpp" // Tracing support extern "C" { -#include "FxSystemWorkItem.tmh" +// #include "FxSystemWorkItem.tmh" } // diff --git a/sdk/lib/drivers/wdf/shared/core/fxtimer.cpp b/sdk/lib/drivers/wdf/shared/core/fxtimer.cpp index 7193f6c409a..63c3e51646f 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxtimer.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxtimer.cpp @@ -26,11 +26,11 @@ Revision History: #include "coreprivshared.hpp" -#include "FxTimer.hpp" +#include "fxtimer.hpp" // Tracing support extern "C" { -#include "FxTimer.tmh" +// #include "FxTimer.tmh" } // @@ -160,10 +160,12 @@ FxTimer::Initialize( // #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) - if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,13)) { - status = m_Timer.InitializeEx(this, FxTimer::_FxTimerExtCallbackThunk, m_Period, - m_TolerableDelay, m_UseHighResolutionTimer); - } else { + // __REACTOS__ Ex timers are not supported + // if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,13)) { + // status = m_Timer.InitializeEx(this, FxTimer::_FxTimerExtCallbackThunk, m_Period, + // m_TolerableDelay, m_UseHighResolutionTimer); + // } else + { status = m_Timer.Initialize(this, FxTimer::_FxTimerDpcThunk, m_Period); } #else diff --git a/sdk/lib/drivers/wdf/shared/core/fxtimerapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxtimerapi.cpp index 3c4a44dacf3..a09f3b3f96c 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxtimerapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxtimerapi.cpp @@ -25,10 +25,10 @@ Revision History: #include "coreprivshared.hpp" -#include "FxTimer.hpp" +#include "fxtimer.hpp" extern "C" { -#include "FxTimerApi.tmh" +// #include "FxTimerApi.tmh" } // @@ -39,6 +39,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfTimerCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -199,6 +200,7 @@ Notes: __drv_maxIRQL(DISPATCH_LEVEL) BOOLEAN +STDCALL WDFEXPORT(WdfTimerStart)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -245,6 +247,7 @@ Returns: __drv_when(Wait == __true, __drv_maxIRQL(PASSIVE_LEVEL)) __drv_when(Wait == __false, __drv_maxIRQL(DISPATCH_LEVEL)) BOOLEAN +STDCALL WDFEXPORT(WdfTimerStop)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -295,6 +298,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) WDFOBJECT +STDCALL WDFEXPORT(WdfTimerGetParentObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/fxworkitem.cpp b/sdk/lib/drivers/wdf/shared/core/fxworkitem.cpp index 2d3fbb55599..7ae80c3214f 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxworkitem.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxworkitem.cpp @@ -26,7 +26,7 @@ Revision History: #include "coreprivshared.hpp" -#include "FxWorkItem.hpp" +#include "fxworkitem.hpp" #if (FX_CORE_MODE == FX_CORE_USER_MODE) // @@ -37,7 +37,7 @@ Revision History: // Tracing support extern "C" { -#include "FxWorkItem.tmh" +// #include "FxWorkItem.tmh" } FxWorkItem::FxWorkItem( @@ -319,8 +319,8 @@ FxWorkItem::Enqueue( // object and Globals while they are outstanding. // These will be released when the workitem completes. // - ADDREF(WorkItemThunk); - pFxDriverGlobals->ADDREF(WorkItemThunk); + ADDREF((PVOID)WorkItemThunk); + pFxDriverGlobals->ADDREF((PVOID)WorkItemThunk); enqueue = TRUE; } @@ -436,12 +436,12 @@ Return Value: // Release the reference on the FxWorkItem and Globals taken when Enqueue // was done. This may release the FxWorkItem if it is running down. // - pWorkItem->RELEASE(WorkItemThunk); + pWorkItem->RELEASE((PVOID)WorkItemThunk); // // This may release the driver if it is running down. // - pFxDriverGlobals->RELEASE(WorkItemThunk); + pFxDriverGlobals->RELEASE((PVOID)WorkItemThunk); } VOID diff --git a/sdk/lib/drivers/wdf/shared/core/fxworkitemapi.cpp b/sdk/lib/drivers/wdf/shared/core/fxworkitemapi.cpp index 3d1930060b5..0c4db13eee5 100644 --- a/sdk/lib/drivers/wdf/shared/core/fxworkitemapi.cpp +++ b/sdk/lib/drivers/wdf/shared/core/fxworkitemapi.cpp @@ -25,10 +25,10 @@ Revision History: #include "coreprivshared.hpp" -#include "FxWorkItem.hpp" +#include "fxworkitem.hpp" extern "C" { -#include "FxWorkItemApi.tmh" +// #include "FxWorkItemApi.tmh" } @@ -40,6 +40,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfWorkItemCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -144,6 +145,7 @@ Notes: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfWorkItemEnqueue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -180,6 +182,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) WDFOBJECT +STDCALL WDFEXPORT(WdfWorkItemGetParentObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -219,6 +222,7 @@ Returns: __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfWorkItemFlush)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxdeviceapikm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxdeviceapikm.cpp index 1588cb823e9..4c481510f6e 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxdeviceapikm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxdeviceapikm.cpp @@ -26,7 +26,7 @@ Revision History: #include "fxiotarget.hpp" extern "C" { -#include "FxDeviceApiKm.tmh" +// #include "FxDeviceApiKm.tmh" } // @@ -58,6 +58,7 @@ VerifyWdfDeviceWdmDispatchIrpToIoQueue, __drv_maxIRQL(DISPATCH_LEVEL) WDFDEVICE +STDCALL WDFEXPORT(WdfWdmDeviceGetWdfDeviceHandle)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -72,6 +73,7 @@ WDFEXPORT(WdfWdmDeviceGetWdfDeviceHandle)( __drv_maxIRQL(DISPATCH_LEVEL) PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfDeviceWdmGetDeviceObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -91,6 +93,7 @@ WDFEXPORT(WdfDeviceWdmGetDeviceObject)( __drv_maxIRQL(DISPATCH_LEVEL) PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfDeviceWdmGetAttachedDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -111,6 +114,7 @@ WDFEXPORT(WdfDeviceWdmGetAttachedDevice)( __drv_maxIRQL(DISPATCH_LEVEL) PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfDeviceWdmGetPhysicalDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -130,6 +134,7 @@ WDFEXPORT(WdfDeviceWdmGetPhysicalDevice)( __drv_maxIRQL(DISPATCH_LEVEL) WDFFILEOBJECT +STDCALL WDFEXPORT(WdfDeviceGetFileObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -206,6 +211,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceWdmDispatchPreprocessedIrp)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -316,6 +322,7 @@ FX_VF_FUNCTION(VerifyWdfDeviceWdmDispatchIrp) ( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceWdmDispatchIrp)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -361,7 +368,7 @@ Returns: FxPointerNotNull(device->GetDriverGlobals(), Irp); FxPointerNotNull(device->GetDriverGlobals(), DispatchContext); - if ((UCHAR)DispatchContext & FX_IN_DISPATCH_CALLBACK) { + if ((UCHAR)(ULONG_PTR)DispatchContext & FX_IN_DISPATCH_CALLBACK) { // // Called from a dispach irp callback. // @@ -395,6 +402,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceWdmDispatchIrpToIoQueue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -497,6 +505,7 @@ WDFEXPORT(WdfDeviceWdmDispatchIrpToIoQueue)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAddDependentUsageDeviceObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -522,6 +531,7 @@ WDFEXPORT(WdfDeviceAddDependentUsageDeviceObject)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceRemoveDependentUsageDeviceObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -548,6 +558,7 @@ WDFEXPORT(WdfDeviceRemoveDependentUsageDeviceObject)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAssignMofResourceName)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -606,6 +617,7 @@ WDFEXPORT(WdfDeviceAssignMofResourceName)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetSpecialFileSupport)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -646,6 +658,7 @@ WDFEXPORT(WdfDeviceSetSpecialFileSupport)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceIndicateWakeStatus)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -706,6 +719,7 @@ WDFEXPORT(WdfDeviceIndicateWakeStatus)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetBusInformationForChildren)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -730,6 +744,7 @@ WDFEXPORT(WdfDeviceSetBusInformationForChildren)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceAddRemovalRelationsPhysicalDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -770,6 +785,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceRemoveRemovalRelationsPhysicalDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -810,6 +826,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceClearRemovalRelationsDevices)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -843,6 +860,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceWdmAssignPowerFrameworkSettings)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxdevicebasekm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxdevicebasekm.cpp index e8576d2519b..858cb67cec9 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxdevicebasekm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxdevicebasekm.cpp @@ -25,7 +25,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxDeviceBaseKm.tmh" +// #include "FxDeviceBaseKm.tmh" } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxdeviceinitkm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxdeviceinitkm.cpp index 37e42d7ca97..a3e5f102164 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxdeviceinitkm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxdeviceinitkm.cpp @@ -25,7 +25,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxDeviceInitKm.tmh" +// #include "FxDeviceInitKm.tmh" } VOID diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxdevicekm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxdevicekm.cpp index 15bcf5aae97..ae3c8c8246b 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxdevicekm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxdevicekm.cpp @@ -25,7 +25,7 @@ Revision History: #include "coreprivshared.hpp" extern "C" { -#include "FxDeviceKm.tmh" +// #include "FxDeviceKm.tmh" } _Must_inspect_result_ @@ -192,10 +192,10 @@ FxDevice::FdoInitialize( return status; } - status = m_PkgWmi->PostCreateDeviceInitialize(); - if (!NT_SUCCESS(status)) { - return status; - } + // status = m_PkgWmi->PostCreateDeviceInitialize(); __REACTOS__ + // if (!NT_SUCCESS(status)) { + // return status; + // } status = m_PkgGeneral->PostCreateDeviceInitialize(DeviceInit); if (!NT_SUCCESS(status)) { @@ -302,10 +302,10 @@ FxDevice::PdoInitialize( pPkgPdo->m_AllowForwardRequestToParent = TRUE; } - status = m_PkgWmi->PostCreateDeviceInitialize(); - if (!NT_SUCCESS(status)) { - return status; - } + // status = m_PkgWmi->PostCreateDeviceInitialize(); __REACTOS__ + // if (!NT_SUCCESS(status)) { + // return status; + // } status = m_PkgGeneral->PostCreateDeviceInitialize(DeviceInit); if (!NT_SUCCESS(status)) { @@ -410,10 +410,10 @@ FxDevice::ControlDeviceInitialize( return status; } - status = m_PkgWmi->PostCreateDeviceInitialize(); - if (!NT_SUCCESS(status)) { - return status; - } + // status = m_PkgWmi->PostCreateDeviceInitialize(); __REACTOS__ + // if (!NT_SUCCESS(status)) { + // return status; + // } status = m_PkgGeneral->PostCreateDeviceInitialize(DeviceInit); if (!NT_SUCCESS(status)) { @@ -489,7 +489,8 @@ FxDevice::WmiPkgRegister( VOID ) { - return m_PkgWmi->Register(); + // return m_PkgWmi->Register(); __REACTOS__ + return STATUS_SUCCESS; } VOID @@ -497,7 +498,7 @@ FxDevice::WmiPkgDeregister( VOID ) { - m_PkgWmi->Deregister(); + // m_PkgWmi->Deregister(); __REACTOS__ } VOID @@ -505,7 +506,7 @@ FxDevice::WmiPkgCleanup( VOID ) { - m_PkgWmi->Cleanup(); + // m_PkgWmi->Cleanup(); __REACTOS__ } NTSTATUS diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxdriverapikm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxdriverapikm.cpp index cb79187e0a8..559b7d28e13 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxdriverapikm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxdriverapikm.cpp @@ -27,7 +27,7 @@ Revision History: // Tracing support extern "C" { #include -#include "FxDriverApiKm.tmh" +// #include "FxDriverApiKm.tmh" } // @@ -38,6 +38,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDriverOpenParametersRegistryKey)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -117,6 +118,7 @@ WDFEXPORT(WdfDriverOpenParametersRegistryKey)( __drv_maxIRQL(DISPATCH_LEVEL) PDRIVER_OBJECT +STDCALL WDFEXPORT(WdfDriverWdmGetDriverObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -136,6 +138,7 @@ WDFEXPORT(WdfDriverWdmGetDriverObject)( __drv_maxIRQL(DISPATCH_LEVEL) WDFDRIVER +STDCALL WDFEXPORT(WdfWdmDriverGetWdfDriverHandle)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -149,6 +152,7 @@ WDFEXPORT(WdfWdmDriverGetWdfDriverHandle)( } VOID +STDCALL WDFEXPORT(WdfDriverMiniportUnload)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -169,6 +173,7 @@ WDFEXPORT(WdfDriverMiniportUnload)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceMiniportCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxdriverkm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxdriverkm.cpp index 46b64c6f82a..9c80b0b1e7f 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxdriverkm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxdriverkm.cpp @@ -29,7 +29,7 @@ Revision History: // Tracing support extern "C" { -#include "FxDriverKm.tmh" +// #include "FxDriverKm.tmh" } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxfileobjectapikm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxfileobjectapikm.cpp index 2c397cb7134..8f487d8fa6d 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxfileobjectapikm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxfileobjectapikm.cpp @@ -22,10 +22,10 @@ Revision History: --*/ #include "coreprivshared.hpp" -#include "FxFileObject.hpp" +#include "fxfileobject.hpp" extern "C" { -#include "FxFileObjectApiKm.tmh" +// #include "FxFileObjectApiKm.tmh" } // @@ -35,6 +35,7 @@ extern "C" { __drv_maxIRQL(DISPATCH_LEVEL) PFILE_OBJECT +STDCALL WDFEXPORT(WdfFileObjectWdmGetFileObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxfileobjectkm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxfileobjectkm.cpp index 61e1fd979e9..53107211bed 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxfileobjectkm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxfileobjectkm.cpp @@ -27,7 +27,7 @@ Revision History: // Tracing support extern "C" { -#include "FxFileObjectKm.tmh" +// #include "FxFileObjectKm.tmh" } VOID diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxnpagedlookasidelistkm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxnpagedlookasidelistkm.cpp index ed81559cb2c..5e9bdbd9c2e 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxnpagedlookasidelistkm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxnpagedlookasidelistkm.cpp @@ -23,8 +23,8 @@ Revision History: #include "coreprivshared.hpp" -#include "FxNPagedLookasideList.hpp" -#include "FxMemoryBufferFromLookaside.hpp" +#include "fxnpagedlookasidelist.hpp" +#include "fxmemorybufferfromlookaside.hpp" FxNPagedLookasideList::FxNPagedLookasideList( __in PFX_DRIVER_GLOBALS FxDriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxrequestkm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxrequestkm.cpp index a5524e2d394..4204367f349 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxrequestkm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxrequestkm.cpp @@ -27,7 +27,7 @@ Revision History: // Tracing support extern "C" { -#include "FxRequestKm.tmh" +// #include "FxRequestKm.tmh" } VOID @@ -51,8 +51,8 @@ Return Value: --*/ { - PWDF_REQUEST_PARAMETERS pWdfRequestParameters; - PIO_STACK_LOCATION pIoStackLocation; + PWDF_REQUEST_PARAMETERS pWdfRequestParameters = NULL; + PIO_STACK_LOCATION pIoStackLocation = NULL; UNREFERENCED_PARAMETER(pWdfRequestParameters); UNREFERENCED_PARAMETER(pIoStackLocation); diff --git a/sdk/lib/drivers/wdf/shared/core/km/fxrequestsystembufferkm.cpp b/sdk/lib/drivers/wdf/shared/core/km/fxrequestsystembufferkm.cpp index 56d62483608..7ffa32f1b30 100644 --- a/sdk/lib/drivers/wdf/shared/core/km/fxrequestsystembufferkm.cpp +++ b/sdk/lib/drivers/wdf/shared/core/km/fxrequestsystembufferkm.cpp @@ -30,7 +30,7 @@ Revision History: // Tracing support extern "C" { -#include "FxRequestSystemBufferKm.tmh" +// #include "FxRequestSystemBufferKm.tmh" } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/enhancedverif/vfpriv.hpp b/sdk/lib/drivers/wdf/shared/enhancedverif/vfpriv.hpp index 61f9a717aec..acafa0c35c4 100644 --- a/sdk/lib/drivers/wdf/shared/enhancedverif/vfpriv.hpp +++ b/sdk/lib/drivers/wdf/shared/enhancedverif/vfpriv.hpp @@ -23,13 +23,13 @@ Revision History: --*/ #if FX_CORE_MODE==FX_CORE_KERNEL_MODE -#include "VfPrivKm.hpp" +#include "vfprivkm.hpp" #else if ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) -#include "VfPrivUm.hpp" +#include "vfprivum.hpp" #endif extern "C" { -#include "FxDynamics.h" +#include "fxdynamics.h" } #include "vfeventhooks.hpp" diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/common/mx.h b/sdk/lib/drivers/wdf/shared/inc/primitives/common/mx.h index 6e5da3ad4a9..2d6301fa565 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/common/mx.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/common/mx.h @@ -25,7 +25,7 @@ Revision History: #pragma once -#include "MxMacros.h" +#include "mxmacros.h" // // Greater than 64 logical processors support: direct DDK to include the new @@ -34,9 +34,11 @@ Revision History: // #define NT_PROCESSOR_GROUPS 1 +#define WDF_VIOLATION ((ULONG)0x0000010DL) + #if (FX_CORE_MODE == FX_CORE_USER_MODE) -#include "MxUm.h" +#include "mxum.h" #elif (FX_CORE_MODE == FX_CORE_KERNEL_MODE) -#include "MxKm.h" +#include "mxkm.h" #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/common/mxdriverobject.h b/sdk/lib/drivers/wdf/shared/inc/primitives/common/mxdriverobject.h index 3a92469b8f6..0ff2e2b2745 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/common/mxdriverobject.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/common/mxdriverobject.h @@ -66,7 +66,7 @@ public: m_DriverObject = DriverObject; } - PVOID + PDRIVER_ADD_DEVICE GetDriverExtensionAddDevice( VOID ); diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/common/mxgeneral.h b/sdk/lib/drivers/wdf/shared/inc/primitives/common/mxgeneral.h index 8301e8ce3b1..edd36bddf9c 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/common/mxgeneral.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/common/mxgeneral.h @@ -126,6 +126,7 @@ public: static + DECLSPEC_NORETURN VOID MxBugCheckEx( __in ULONG BugCheckCode, diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxdeviceobjectkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxdeviceobjectkm.h index 5bb6126e279..0ffb738fff2 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxdeviceobjectkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxdeviceobjectkm.h @@ -14,7 +14,7 @@ Abstract: #pragma once -#include "MxDeviceObject.h" +#include "mxdeviceobject.h" __inline CCHAR @@ -65,7 +65,9 @@ MxDeviceObject::GetFlags( VOID ) { +#ifdef _MSC_VER #pragma warning(disable:28129) +#endif return m_DeviceObject->Flags; } @@ -75,7 +77,9 @@ MxDeviceObject::SetFlags( ULONG Flags ) { +#ifdef _MSC_VER #pragma warning(disable:28129) +#endif m_DeviceObject->Flags = Flags; } diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxdriverobjectkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxdriverobjectkm.h index 796a4a5bc6d..2b5b87ae5ad 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxdriverobjectkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxdriverobjectkm.h @@ -18,10 +18,10 @@ typedef DRIVER_ADD_DEVICE MdDriverAddDeviceType, *MdDriverAddDevice; typedef DRIVER_UNLOAD MdDriverUnloadType, *MdDriverUnload; typedef DRIVER_DISPATCH MdDriverDispatchType, *MdDriverDispatch; -#include "MxDriverObject.h" +#include "mxdriverobject.h" __inline -PVOID +PDRIVER_ADD_DEVICE MxDriverObject::GetDriverExtensionAddDevice( VOID ) diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxeventkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxeventkm.h index 16e27bbc0c0..13b29bd58ec 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxeventkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxeventkm.h @@ -25,7 +25,7 @@ Revision History: typedef KEVENT MdEvent; -#include "MxEvent.h" +#include "mxevent.h" __inline MxEvent::MxEvent() @@ -49,7 +49,9 @@ MxEvent::~MxEvent() __inline NTSTATUS +#ifdef _MSC_VER #pragma prefast(suppress:__WARNING_UNMATCHED_DECL_ANNO, "_Must_inspect_result_ not needed in kernel mode as the function always succeeds"); +#endif MxEvent::Initialize( __in EVENT_TYPE Type, __in BOOLEAN InitialState diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxfileobjectkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxfileobjectkm.h index b90c992f551..0a8da34a0b2 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxfileobjectkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxfileobjectkm.h @@ -14,7 +14,7 @@ Abstract: #pragma once -#include "MxFileObject.h" +#include "mxfileobject.h" __inline PUNICODE_STRING diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxgeneralkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxgeneralkm.h index 58582c89294..9fb6a76fb4b 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxgeneralkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxgeneralkm.h @@ -37,7 +37,7 @@ typedef PKINTERRUPT MdInterrupt; typedef KSERVICE_ROUTINE MdInterruptServiceRoutineType, *MdInterruptServiceRoutine; typedef KSYNCHRONIZE_ROUTINE MdInterruptSynchronizeRoutineType, *MdInterruptSynchronizeRoutine; -#include "MxGeneral.h" +#include "mxgeneral.h" #include __inline @@ -138,7 +138,9 @@ Mx::MxBugCheckEx( __in ULONG_PTR BugCheckParameter4 ) { +#ifdef _MSC_VER #pragma prefast(suppress:__WARNING_USE_OTHER_FUNCTION, "KeBugCheckEx is the intent."); +#endif KeBugCheckEx( BugCheckCode, BugCheckParameter1, @@ -146,6 +148,8 @@ Mx::MxBugCheckEx( BugCheckParameter3, BugCheckParameter4 ); + + UNREACHABLE; } __inline @@ -177,7 +181,9 @@ Mx::MxAssertMsg( UNREFERENCED_PARAMETER(Message); UNREFERENCED_PARAMETER(Condition); - ASSERTMSG(Message, Condition); + ASSERT(Condition); + + // ASSERTMSG(Message, Condition); TODO: wtf } _Acquires_lock_(_Global_critical_region_) @@ -524,6 +530,7 @@ Mx::MxCreateDeviceSecure( _Out_ MdDeviceObject *DeviceObject ) { +#ifndef __REACTOS__ // we don't have wdmsec.lib return IoCreateDeviceSecure(DriverObject, DeviceExtensionSize, DeviceName, @@ -533,6 +540,16 @@ Mx::MxCreateDeviceSecure( DefaultSDDLString, DeviceClassGuid, DeviceObject); +#else + return IoCreateDevice( + DriverObject, + DeviceExtensionSize, + DeviceName, + DeviceType, + DeviceCharacteristics, + Exclusive, + DeviceObject); +#endif } __inline diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxkm.h index 3933be326a3..cc2ca32cb61 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxkm.h @@ -26,24 +26,24 @@ Revision History: #pragma once #include -#include -#include +// #include +// #include -#include -#include +// #include +// #include typedef KDEFERRED_ROUTINE MdDeferredRoutineType, *MdDeferredRoutine; typedef EXT_CALLBACK MdExtCallbackType, *MdExtCallback; #define FX_DEVICEMAP_PATH L"\\REGISTRY\\MACHINE\\HARDWARE\\DEVICEMAP\\" -#include "MxGeneralKm.h" -#include "MxLockKm.h" -#include "MxPagedLockKm.h" -#include "MxEventKm.h" -#include "MxMemoryKm.h" -#include "MxTimerKm.h" -#include "MxWorkItemKm.h" -#include "MxDriverObjectKm.h" -#include "MxDeviceObjectKm.h" -#include "MxFileObjectKm.h" +#include "mxgeneralkm.h" +#include "mxlockkm.h" +#include "mxpagedlockkm.h" +#include "mxeventkm.h" +#include "mxmemorykm.h" +#include "mxtimerkm.h" +#include "mxworkitemkm.h" +#include "mxdriverobjectkm.h" +#include "mxdeviceobjectkm.h" +#include "mxfileobjectkm.h" diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxlockkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxlockkm.h index eb019725974..83b2ff07656 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxlockkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxlockkm.h @@ -23,11 +23,11 @@ Revision History: #pragma once -#include "DbgMacros.h" +#include "dbgmacros.h" typedef KSPIN_LOCK MdLock; -#include "MxLock.h" +#include "mxlock.h" __inline MxLock::MxLock( diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxmemorykm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxmemorykm.h index 958953c7d9d..1a1ab9cd055 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxmemorykm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxmemorykm.h @@ -23,7 +23,7 @@ Revision History: #pragma once -#include "MxMemory.h" +#include "mxmemory.h" __inline PVOID diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxpagedlockkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxpagedlockkm.h index deace98e4db..13db20b2ba5 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxpagedlockkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxpagedlockkm.h @@ -23,11 +23,11 @@ Revision History: #pragma once -#include "DbgMacros.h" +#include "dbgmacros.h" typedef FAST_MUTEX MdPagedLock; -#include "MxPagedLock.h" +#include "mxpagedlock.h" __inline MxPagedLock::MxPagedLock( @@ -46,7 +46,9 @@ MxPagedLock::MxPagedLock( __inline NTSTATUS +#ifdef _MSC_VER #pragma prefast(suppress:__WARNING_UNMATCHED_DEFN, "_Must_inspect_result_ not needed in kernel mode as the function always succeeds"); +#endif MxPagedLockNoDynam::Initialize( ) { diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxtimerkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxtimerkm.h index 3284b451cb8..9bc1d4de1af 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxtimerkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxtimerkm.h @@ -47,8 +47,8 @@ typedef struct _MdTimer { // BOOLEAN m_IsExtTimer; -#pragma warning(push) -#pragma warning( disable: 4201 ) // nonstandard extension used : nameless struct/union +// #pragma warning(push) +// #pragma warning( disable: 4201 ) // nonstandard extension used : nameless struct/union union { struct { @@ -69,7 +69,7 @@ typedef struct _MdTimer { }; }; -#pragma warning(pop) +// #pragma warning(pop) // // Context to be passed in to the callback function @@ -78,7 +78,7 @@ typedef struct _MdTimer { } MdTimer; -#include "MxTimer.h" +#include "mxtimer.h" MxTimer::MxTimer( VOID @@ -94,25 +94,28 @@ MxTimer::~MxTimer( VOID ) { - BOOLEAN wasCancelled; + // __REACTOS__ Ex timers are not supported + // BOOLEAN wasCancelled; - if (m_Timer.m_IsExtTimer && - m_Timer.m_KernelExTimer) { - wasCancelled = ExDeleteTimer(m_Timer.m_KernelExTimer, - TRUE, // Cancel if pending. We don't expect - // it to be pending though - FALSE,// Wait - NULL); - // - // Timer should not have been pending - // - ASSERT(wasCancelled == FALSE); - m_Timer.m_KernelExTimer = NULL; - } + // if (m_Timer.m_IsExtTimer && + // m_Timer.m_KernelExTimer) { + // wasCancelled = ExDeleteTimer(m_Timer.m_KernelExTimer, + // TRUE, // Cancel if pending. We don't expect + // // it to be pending though + // FALSE,// Wait + // NULL); + // // + // // Timer should not have been pending + // // + // ASSERT(wasCancelled == FALSE); + // m_Timer.m_KernelExTimer = NULL; + // } } NTSTATUS +#ifdef _MSC_VER #pragma prefast(suppress:__WARNING_UNMATCHED_DECL_ANNO, "_Must_inspect_result_ not needed in kernel mode as the function always succeeds"); +#endif MxTimer::Initialize( __in_opt PVOID TimerContext, __in MdDeferredRoutine TimerCallback, @@ -166,37 +169,38 @@ Returns: --*/ { - NTSTATUS status; - ULONG attributes = 0; + // NTSTATUS status; + // ULONG attributes = 0; - m_Timer.m_TimerContext = TimerContext; - m_Timer.m_ExTimerCallback = TimerCallback; - m_Timer.m_Period = Period; + // m_Timer.m_TimerContext = TimerContext; + // m_Timer.m_ExTimerCallback = TimerCallback; + // m_Timer.m_Period = Period; - if (TolerableDelay != 0) { + // if (TolerableDelay != 0) { - attributes |= EX_TIMER_NO_WAKE; + // attributes |= EX_TIMER_NO_WAKE; - } else if (UseHighResolutionTimer) { + // } else if (UseHighResolutionTimer) { - attributes |= EX_TIMER_HIGH_RESOLUTION; - } + // attributes |= EX_TIMER_HIGH_RESOLUTION; + // } - m_Timer.m_KernelExTimer = ExAllocateTimer(m_Timer.m_ExTimerCallback, - TimerContext, - attributes); - if (m_Timer.m_KernelExTimer) { + // m_Timer.m_KernelExTimer = ExAllocateTimer(m_Timer.m_ExTimerCallback, + // TimerContext, + // attributes); + // if (m_Timer.m_KernelExTimer) { - status = STATUS_SUCCESS; + // status = STATUS_SUCCESS; - } else { + // } else { - status = STATUS_INSUFFICIENT_RESOURCES; - } + // status = STATUS_INSUFFICIENT_RESOURCES; + // } - m_Timer.m_IsExtTimer = TRUE; + // m_Timer.m_IsExtTimer = TRUE; - return status; + // return status; + return STATUS_NOT_IMPLEMENTED; // __REACTOS__ Ex timers are not supported } @@ -208,29 +212,29 @@ MxTimer::StartWithReturn( ) { if (m_Timer.m_IsExtTimer) { + // __REACTOS__ Ex timers are not supported + // EXT_SET_PARAMETERS parameters; - EXT_SET_PARAMETERS parameters; + // ExInitializeSetTimerParameters(¶meters); - ExInitializeSetTimerParameters(¶meters); - - // - // We get the delay in ms but the underlying API needs it in 100 ns - // units. Convert tolerable delay from ms to 100 ns. However, - // MAXULONG (TolerableDelayUnlimited) has a special meaning that the - // system should never be woken up, so we assign the corresponding - // special value for Ex timers - // - if (TolerableDelay == TolerableDelayUnlimited) { - parameters.NoWakeTolerance = EX_TIMER_UNLIMITED_TOLERANCE; - } else { - parameters.NoWakeTolerance = ((LONGLONG) TolerableDelay) * 10 * 1000; - } - - return ExSetTimer(m_Timer.m_KernelExTimer, - DueTime.QuadPart, - (((LONGLONG) m_Timer.m_Period) * 10 * 1000), - ¶meters); + // // + // // We get the delay in ms but the underlying API needs it in 100 ns + // // units. Convert tolerable delay from ms to 100 ns. However, + // // MAXULONG (TolerableDelayUnlimited) has a special meaning that the + // // system should never be woken up, so we assign the corresponding + // // special value for Ex timers + // // + // if (TolerableDelay == TolerableDelayUnlimited) { + // parameters.NoWakeTolerance = EX_TIMER_UNLIMITED_TOLERANCE; + // } else { + // parameters.NoWakeTolerance = ((LONGLONG) TolerableDelay) * 10 * 1000; + // } + // return ExSetTimer(m_Timer.m_KernelExTimer, + // DueTime.QuadPart, + // (((LONGLONG) m_Timer.m_Period) * 10 * 1000), + // ¶meters); + return FALSE; } else { return KeSetCoalescableTimer(&(m_Timer.KernelTimer), @@ -273,7 +277,8 @@ MxTimer::Stop( BOOLEAN bRetVal; if (m_Timer.m_IsExtTimer) { - bRetVal = ExCancelTimer(m_Timer.m_KernelExTimer, NULL); + bRetVal = FALSE; + // bRetVal = ExCancelTimer(m_Timer.m_KernelExTimer, NULL); // __REACTOS__ Ex timers are not supported } else { bRetVal = KeCancelTimer(&(m_Timer.KernelTimer)); diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxworkitemkm.h b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxworkitemkm.h index 930476b7f6e..07dcc2b9691 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxworkitemkm.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/km/mxworkitemkm.h @@ -26,7 +26,7 @@ Revision History: typedef IO_WORKITEM_ROUTINE MX_WORKITEM_ROUTINE, *PMX_WORKITEM_ROUTINE; typedef PIO_WORKITEM MdWorkItem; -#include "MxWorkItem.h" +#include "mxworkitem.h" __inline MxWorkItem::MxWorkItem( diff --git a/sdk/lib/drivers/wdf/shared/inc/primitives/um/mxum.h b/sdk/lib/drivers/wdf/shared/inc/primitives/um/mxum.h index f2153977ea6..359b8990316 100644 --- a/sdk/lib/drivers/wdf/shared/inc/primitives/um/mxum.h +++ b/sdk/lib/drivers/wdf/shared/inc/primitives/um/mxum.h @@ -45,8 +45,6 @@ typedef PVOID PIO_REMOVE_LOCK; #include "wdmdefs.h" -#define WDF_VIOLATION ((ULONG)0x0000010DL) - #define FX_PLUGPLAY_REGKEY_DEVICEMAP 0x8 // diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/dbgtrace.h b/sdk/lib/drivers/wdf/shared/inc/private/common/dbgtrace.h index ed55b2ae486..e6021f39339 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/dbgtrace.h +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/dbgtrace.h @@ -68,6 +68,9 @@ Revision History: #define TRACINGDRIVER 0x00001000 #define TRACINGPNPPOWERSTATES 0x00002000 +#define TRACINGDMA 0x00004000 // __REACTOS__ +#define TRACINGIOTARGET 0x00008000 // __REACTOS__ + extern "C" { void __cdecl @@ -93,7 +96,9 @@ DoTraceLevelMessage ( #define WPP_CLEANUP(DriverObject) #endif +extern "C" { extern ULONG DebugLevel; extern ULONG DebugFlag; +} #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxcallbackmutexlock.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxcallbackmutexlock.hpp index 0cfa17bfb3d..88f236e569d 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxcallbackmutexlock.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxcallbackmutexlock.hpp @@ -28,7 +28,7 @@ Revision History: #define _FXCALLBACKMUTEXLOCK_H_ extern "C" { -#include "FxCallbackMutexLock.hpp.tmh" +// #include "FxCallbackMutexLock.hpp.tmh" } class FxCallbackMutexLock : public FxCallbackLock { diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxcxdeviceinfo.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxcxdeviceinfo.hpp index 9c8c7ab82c4..7b17800bfca 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxcxdeviceinfo.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxcxdeviceinfo.hpp @@ -4,7 +4,7 @@ #ifndef _FXCXDEVICEINFO_H_ #define _FXCXDEVICEINFO_H_ -#include "FxDeviceCallbacks.hpp" +#include "fxdevicecallbacks.hpp" struct FxCxDeviceInfo : public FxStump { FxCxDeviceInfo(PFX_DRIVER_GLOBALS FxDriverGlobals) : diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxcxdeviceinit.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxcxdeviceinit.hpp index 45499e369d2..f5933496008 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxcxdeviceinit.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxcxdeviceinit.hpp @@ -91,5 +91,5 @@ public: FxCxDeviceInfo* CxDeviceInfo; }; -#endif __FXCXDEVICEINIT_HPP__ +#endif // __FXCXDEVICEINIT_HPP__ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxdevice.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxdevice.hpp index 8a83180b230..78aff7279f1 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxdevice.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxdevice.hpp @@ -25,9 +25,9 @@ Revision History: #ifndef _FXDEVICE_H_ #define _FXDEVICE_H_ -#include "FxCxDeviceInit.hpp" -#include "FxDeviceInit.hpp" -#include "FxTelemetry.hpp" +#include "fxcxdeviceinit.hpp" +#include "fxdeviceinit.hpp" +#include "fxtelemetry.hpp" struct FxWdmDeviceExtension { #if (FX_CORE_MODE == FX_CORE_USER_MODE) @@ -1022,6 +1022,7 @@ public: static _Must_inspect_result_ NTSTATUS + STDCALL Dispatch( __in MdDeviceObject DeviceObject, __in MdIrp OriginalIrp @@ -1065,6 +1066,7 @@ public: static _Must_inspect_result_ NTSTATUS + STDCALL DispatchWithLock( __in MdDeviceObject DeviceObject, __in MdIrp OriginalIrp @@ -1470,7 +1472,7 @@ public: // ASSERT(m_DeviceObjectDeleted); - __super::DeleteObject(); + FxDeviceBase::DeleteObject(); // __super call } _Must_inspect_result_ @@ -1761,6 +1763,7 @@ public: static VOID + STDCALL _InterfaceReferenceNoOp( __in_opt PVOID Context ) @@ -1771,6 +1774,7 @@ public: static VOID + STDCALL _InterfaceDereferenceNoOp( __in_opt PVOID Context ) @@ -1795,7 +1799,7 @@ public: VOID ) { - LogDeviceStartTelemetryEvent(GetDriverGlobals(), this); + // LogDeviceStartTelemetryEvent(GetDriverGlobals(), this); __REACTOS__ : no-op } virtual @@ -2288,9 +2292,9 @@ public: }; #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) -#include "FxDeviceKm.hpp" +#include "fxdevicekm.hpp" #else -#include "FxDeviceUm.hpp" +#include "fxdeviceum.hpp" #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxdeviceinit.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxdeviceinit.hpp index 0608cd4a1fb..a6cd593ff16 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxdeviceinit.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxdeviceinit.hpp @@ -78,7 +78,7 @@ struct FdoInit { -#include "FxDeviceInitShared.hpp" +#include "fxdeviceinitshared.hpp" struct ControlInit { ControlInit( @@ -327,4 +327,4 @@ public: }; -#endif __FXDEVICEINIT_HPP__ +#endif // __FXDEVICEINIT_HPP__ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxdevicetext.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxdevicetext.hpp index 42561296e88..c64d78e49f2 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxdevicetext.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxdevicetext.hpp @@ -49,6 +49,7 @@ struct FxDeviceText : public FxStump { } static + void _CleanupList( __inout PSINGLE_LIST_ENTRY Head ) diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxdriver.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxdriver.hpp index 0f9c1c472bd..518e206b7fc 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxdriver.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxdriver.hpp @@ -25,7 +25,7 @@ Revision History: #ifndef _FXDRIVER_H_ #define _FXDRIVER_H_ -#include "FxDriverCallbacks.hpp" +#include "fxdrivercallbacks.hpp" // @@ -46,7 +46,7 @@ struct FxTraceInfo { // Unique value to retrieve the FxDriver* from the MdDriverObject. Use a value // that is not exposed to the driver writer through the dispatch table or WDM. // -#define FX_DRIVER_ID (FxDriver::GetFxDriver) +#define FX_DRIVER_ID ((PVOID)FxDriver::GetFxDriver) // // The following are support classes for FxDriver @@ -321,7 +321,7 @@ public: break; default: - return __super::QueryInterface(Params); + return FxNonPagedObject::QueryInterface(Params); // __super call } return STATUS_SUCCESS; @@ -340,7 +340,7 @@ public: // ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL); - __super::DeleteObject(); + FxNonPagedObject::DeleteObject(); // __super call } virtual diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxforward.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxforward.hpp index ac73b1ed26f..56fd96fb08d 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxforward.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxforward.hpp @@ -117,9 +117,11 @@ class FxWorkItem; class IFxHasCallbacks; class IFxMemory; -enum FxObjectType; -enum FxWmiInstanceAction; +enum FxObjectType : UINT32; +enum FxWmiInstanceAction : UINT32; enum FxDriverObjectUmFlags : USHORT; +enum FxWakeInterruptEvents : UINT32; + PVOID FxObjectHandleAlloc( @@ -133,7 +135,7 @@ FxObjectHandleAlloc( ); #if (FX_CORE_MODE==FX_CORE_USER_MODE) -#include "FxForwardUm.hpp" +#include "fxforwardum.hpp" #endif #endif // _FXFORWARD_HPP_ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxglobals.h b/sdk/lib/drivers/wdf/shared/inc/private/common/fxglobals.h index 606a40ad037..46c0d9abd85 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxglobals.h +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxglobals.h @@ -46,6 +46,11 @@ Revision History: #define _FXGLOBALS_H #include "wdfglobals.h" +#include + +// REACTOS +#define ROSWDFNOTIMPLEMENTED (DbgPrint("(%s:%d) ReactOS KMDF: %s not implemented\n", __RELFILE__, __LINE__, __FUNCTION__)) +// REACTOS #ifdef __cplusplus extern "C" { @@ -68,7 +73,7 @@ typedef enum FxTrackPowerOption : UCHAR { FxTrackPowerRefs, FxTrackPowerRefsAndStack, FxTrackPowerMaxValue -}; +} FxTrackPowerOption; typedef enum FxVerifierDownlevelOption { NotOkForDownLevel = 0, @@ -847,13 +852,15 @@ struct FxLibraryGlobalsType { // tracing of WDF operations. The size member of this structure // allows versioning across multiple OS versions. // - PWMI_WDF_NOTIFY_ROUTINES PerfTraceRoutines; + //PWMI_WDF_NOTIFY_ROUTINES PerfTraceRoutines; __REACTOS__ + PVOID PerfTraceRoutines; // // PerfTraceRoutines points here if the SystemTraceProvider failed // to provide trace routines. // - WMI_WDF_NOTIFY_ROUTINES DummyPerfTraceRoutines; + //WMI_WDF_NOTIFY_ROUTINES DummyPerfTraceRoutines; __REACTOS__ + PVOID DummyPerfTraceRoutines; #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxinterrupt.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxinterrupt.hpp index ab0d9b97f55..e97df12bee5 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxinterrupt.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxinterrupt.hpp @@ -27,7 +27,7 @@ Revision History: #ifndef _FXINTERRUPT_H_ #define _FXINTERRUPT_H_ -#include "FxWakeInterruptStateMachine.hpp" +#include "fxwakeinterruptstatemachine.hpp" // // We need two parameters for KeSynchronizeExecution when enabling @@ -271,7 +271,7 @@ public: _Must_inspect_result_ NTSTATUS - FxInterrupt::CreateWakeInterruptMachine( + CreateWakeInterruptMachine( VOID ); diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxioqueue.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxioqueue.hpp index ed403dba3ce..226d603de8c 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxioqueue.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxioqueue.hpp @@ -28,7 +28,7 @@ Revision History: #ifndef _FXIOQUEUE_H_ #define _FXIOQUEUE_H_ -#include "FxIoQueueCallbacks.hpp" +#include "fxioqueuecallbacks.hpp" extern "C" { #if defined(EVENT_TRACING) @@ -1089,7 +1089,7 @@ public: break; default: - return __super::QueryInterface(Params); + return FxNonPagedObject::QueryInterface(Params); // __super call } return STATUS_SUCCESS; @@ -1230,7 +1230,7 @@ public: return CONTAINING_RECORD(Entry, FxIoQueue, m_PowerSListEntry); } - __declspec(noreturn) + DECLSPEC_NORETURN VOID FatalError( __in NTSTATUS Status @@ -1705,9 +1705,9 @@ protected: }; #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) -#include "FxIoQueueKm.hpp" +#include "fxioqueuekm.hpp" #else -#include "FxIoQueueUm.hpp" +#include "fxioqueueum.hpp" #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxiotarget.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxiotarget.hpp index af69d77113e..f6493332a0f 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxiotarget.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxiotarget.hpp @@ -155,7 +155,7 @@ struct FxInternalIoctlOthersContext : public FxRequestContext { } } - __super::ReleaseAndRestore(Request); + FxRequestContext::ReleaseAndRestore(Request); // __super call } private: @@ -165,7 +165,7 @@ private: __in FxRequestBuffer* Buffer ) { - __super::StoreAndReferenceMemory(Buffer); + FxRequestContext::StoreAndReferenceMemory(Buffer); // __super call } public: @@ -958,9 +958,9 @@ protected: #if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE)) -#include "FxIoTargetKm.hpp" -#else if ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) -#include "FxIoTargetUm.hpp" +#include "fxiotargetkm.hpp" +#elif ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) +#include "fxiotargetum.hpp" #endif #endif //_FXIOTARGET_H_ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxiotargetremote.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxiotargetremote.hpp index c2010ca6ebb..316f7efd14e 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxiotargetremote.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxiotargetremote.hpp @@ -311,13 +311,13 @@ protected: return STATUS_SUCCESS; } else { - return __super::QueryInterface(Params); + return FxIoTarget::QueryInterface(Params); // __super call } } _Must_inspect_result_ NTSTATUS - FxIoTargetRemote::OpenLocalTargetByFile( + OpenLocalTargetByFile( _In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams ); @@ -432,9 +432,9 @@ protected: }; #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) -#include "FxIoTargetRemoteKm.hpp" +#include "fxiotargetremotekm.hpp" #else -#include "FxIoTargetRemoteUm.hpp" +#include "fxiotargetremoteum.hpp" #endif #endif // _FXIOTARGETREMOTE_H_ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxirp.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxirp.hpp index d8cf80a88f4..da543c3b448 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxirp.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxirp.hpp @@ -20,72 +20,33 @@ Environment: Revision History: +--*/ +#ifndef _FXIRP_HPP_ +#define _FXIRP_HPP_ +class FxIrp { + friend struct FxAutoIrp; +private: + MdIrp m_Irp; +public: + FxIrp() {} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + FxIrp(MdIrp irp) : m_Irp(irp) + { + } // A function for when not assigning + MdIrp + SetIrp( + MdIrp irp + ); + MdIrp GetIrp( VOID @@ -743,6 +704,7 @@ private: static NTSTATUS + STDCALL _IrpSynchronousCompletion( __in MdDeviceObject DeviceObject, __in MdIrp OriginalIrp, @@ -841,4 +803,4 @@ struct FxAutoIrp : public FxIrp { ~FxAutoIrp(); }; -#endif // _FXIRP_H_ +#endif // _FXIRP_HPP_ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxirpqueue.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxirpqueue.hpp index 31c09cfa3d9..7eea0fe8c61 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxirpqueue.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxirpqueue.hpp @@ -31,9 +31,9 @@ Revision History: #define _FXIRPQUEUE_H_ #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) -#include "FxIrpKm.hpp" +#include "fxirpkm.hpp" #else -#include "FxIrpUm.hpp" +#include "fxirpum.hpp" #endif @@ -52,9 +52,9 @@ Revision History: #define FX_IRP_QUEUE_ENTRY_IDENTIFIER 1 #if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE)) -#include "FxIrpKm.hpp" -#else if ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) -#include "FxIrpUm.hpp" +#include "fxirpkm.hpp" +#elif ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) +#include "fxirpum.hpp" #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxldr.h b/sdk/lib/drivers/wdf/shared/inc/private/common/fxldr.h index 46c196e07b2..06a4745349c 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxldr.h +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxldr.h @@ -218,7 +218,7 @@ WdfRegisterLibrary( #pragma alloc_text (PAGE, WdfVersionBind) #pragma alloc_text (PAGE, WdfVersionUnbind) #pragma alloc_text (PAGE, WdfRegisterLibrary) -#pragma alloc_text (PAGE, WdfRegisterClassLibrary) +// #pragma alloc_text (PAGE, WdfRegisterClassLibrary) #endif #ifdef __cplusplus @@ -246,4 +246,4 @@ WdfRegisterLibrary( TraceLoggingWideString(ClientImageName, "ClientImageName" ) \ ); -#endif __FXLDR_H__ +#endif // __FXLDR_H__ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxmacros.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxmacros.hpp index 55636b10a69..8fb90ee3bba 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxmacros.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxmacros.hpp @@ -22,14 +22,14 @@ -#if defined(_M_ARM) +#if defined(_M_ARM) || defined(__REACTOS__) #define FX_VF_PAGING #else #define FX_VF_PAGING __declspec(code_seg(FX_VF_SECTION_NAME_QUOTED(WDF_FX_VF_SECTION_NAME))) #endif #define FX_VF_NAME_TO_IMP_NAME( fnName ) Vf_##fnName -#define FX_VF_NAME_TO_SCOPED_IMP_NAME( classname, fnName ) classname##::Vf_##fnName +#define FX_VF_NAME_TO_SCOPED_IMP_NAME( classname, fnName ) classname::Vf_##fnName #define FX_VF_QF_VOID #define FX_VF_QF_NTSTATUS _Must_inspect_result_ #define FX_VF_DEFAULT_RT_VOID diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxmdl.h b/sdk/lib/drivers/wdf/shared/inc/private/common/fxmdl.h index a0fe56abe8f..f51699c91f2 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxmdl.h +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxmdl.h @@ -88,4 +88,4 @@ FxIrpMdlFree( #define IoAllocateMdl use_FxMdlAllocate_instead #define IoFreeMdl use_FxMdlFree_instead -#endif __FXMDL_H__ +#endif // __FXMDL_H__ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxmemoryobject.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxmemoryobject.hpp index 3d664989fd8..c918b7f3a7f 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxmemoryobject.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxmemoryobject.hpp @@ -189,7 +189,7 @@ protected: return STATUS_SUCCESS; default: - return __super::QueryInterface(Params); + return FxObject::QueryInterface(Params); // __super call } } diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxmin.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxmin.hpp index 866a63e680f..8815cbebe76 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxmin.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxmin.hpp @@ -34,7 +34,7 @@ Revision History: extern "C" { #include "mx.h" } -#include "FxMacros.hpp" +#include "fxmacros.hpp" #if (FX_CORE_MODE == FX_CORE_USER_MODE) // @@ -81,15 +81,15 @@ extern const WDFFUNC *WdfFunctions; #include "wdfcore.h" #include "wdfdevice.h" -#include "wdfdevicepri.h" -#include "wdfiotargetpri.h" +// #include "wdfdevicepri.h" +// #include "wdfiotargetpri.h" #include "wdfdriver.h" #include "wdfmemory.h" #include "wdfrequest.h" #include "wdfwmi.h" -#include "wdfChildList.h" +#include "wdfchildlist.h" #include "wdfpdo.h" #include "wdffdo.h" #include "wdfiotarget.h" @@ -113,9 +113,9 @@ extern const WDFFUNC *WdfFunctions; #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 +// #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" @@ -160,7 +160,7 @@ typedef struct _WDF_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" +// #include "cobbled.hpp" } //extern "C" @@ -187,10 +187,10 @@ typedef enum _TRACE_INFORMATION_CLASS { #include #endif // FX_CORE_MODE==FX_CORE_USER_MODE -#include "FxForward.hpp" +#include "fxforward.hpp" #if (FX_CORE_MODE == FX_CORE_USER_MODE) -#include "HostFxUtil.h" +#include "hostfxutil.h" #include "wdfplatform.h" #include "wdfplatformimpl.h" #include "debug.h" @@ -198,187 +198,187 @@ typedef enum _TRACE_INFORMATION_CLASS { #include "wudfx_namespace_on.h" #include "wudfx.h" #include "wudfx_namespace_off.h" -#include "DriverFrameworks-UserMode-UmEvents.h" +#include "driverframeworks-usermode-umevents.h" #endif #include "fxtypedefs.hpp" #if defined(EVENT_TRACING) #include "fxwmicompat.h" -#include "FxTrace.h" +#include "fxtrace.h" #else -#include "DbgTrace.h" +#include "dbgtrace.h" #endif // EVENT_TRACING -#include "FxTypes.h" +#include "fxtypes.h" #include "fxrequestcontexttypes.h" -#include "FxPool.h" +#include "fxpool.h" #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) -#include "FxGlobalsKm.h" -#include "FxPerfTraceKm.hpp" -#include "DriverFrameworks-KernelMode-KmEvents.h" +#include "fxglobalskm.h" +#include "fxperftracekm.hpp" +// #include "DriverFrameworks-KernelMode-KmEvents.h" #else -#include "FxGlobalsUm.h" +#include "fxglobalsum.h" #endif -#include "FxPoolInlines.hpp" +#include "fxpoolinlines.hpp" #include "fxverifier.h" #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) -#include "FxVerifierKm.h" +#include "fxverifierkm.h" #else -#include "FxVerifierUm.h" +#include "fxverifierum.h" #include "device_common.h" #endif #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) -#include "FxMdl.h" +#include "fxmdl.h" #endif -#include "FxProbeAndLock.h" +#include "fxprobeandlock.h" //#include "FxPerfTraceKm.hpp" //#include -#include "FxStump.hpp" -#include "FxRequestBuffer.hpp" -#include "FxTagTracker.hpp" +#include "fxstump.hpp" +#include "fxrequestbuffer.hpp" +#include "fxtagtracker.hpp" // internal locks -#include "FxVerifierLock.hpp" -#include "FxLock.hpp" +#include "fxverifierlock.hpp" +#include "fxlock.hpp" // base objects -#include "FxObject.hpp" -#include "FxPagedObject.hpp" -#include "FxNonPagedObject.hpp" +#include "fxobject.hpp" +#include "fxpagedobject.hpp" +#include "fxnonpagedobject.hpp" #include "fxhandle.h" // external locks -#include "FxWaitLock.hpp" +#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" +#include "fxtransactionedlist.hpp" +#include "fxrelateddevicelist.hpp" +#include "fxdisposelist.hpp" +#include "fxcollection.hpp" +#include "stringutil.hpp" // abstract classes -#include "IFxHasCallbacks.hpp" +#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 "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 "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 "fxvalidatefunctions.hpp" -#include "FxResource.hpp" -#include "FxRelatedDevice.hpp" -#include "FxDeviceInterface.hpp" -#include "FxQueryInterface.hpp" -#include "FxDeviceText.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" +#include "fxirpum.hpp" +#include "fxinterruptthreadpoolum.hpp" #else -#include "FxIrpKm.hpp" +#include "fxirpkm.hpp" #endif -#include "FxDriver.hpp" +#include "fxdriver.hpp" // generic package interface -#include "FxPackage.hpp" -#include "FxPkgGeneral.hpp" -#include "FxDefaultIrpHandler.hpp" -//#include "FxPoxKm.hpp" -#include "FxPkgPnp.hpp" -#include "FxWatchDog.hpp" +#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 "fxchildlist.hpp" +#include "fxcxdeviceinfo.hpp" -#include "FxDevice.hpp" +#include "fxdevice.hpp" -#include "FxPkgIo.hpp" +#include "fxpkgio.hpp" -#include "FxDeviceToMxInterface.hpp" +#include "fxdevicetomxinterface.hpp" -#include "FxIrpQueue.hpp" -#include "FxRequestContext.hpp" -#include "FxRequestCallbacks.hpp" -#include "FxRequestBase.hpp" -#include "FxRequest.hpp" -#include "FxSyncRequest.hpp" +#include "fxirpqueue.hpp" +#include "fxrequestcontext.hpp" +#include "fxrequestcallbacks.hpp" +#include "fxrequestbase.hpp" +#include "fxrequest.hpp" +#include "fxsyncrequest.hpp" -#include "FxRequestValidateFunctions.hpp" +#include "fxrequestvalidatefunctions.hpp" // specialized irp handlers (ie packages) -#include "FxPkgFdo.hpp" -#include "FxPkgPdo.hpp" +#include "fxpkgfdo.hpp" +#include "fxpkgpdo.hpp" -//#include "FxWmiIrpHandler.hpp" -//#include "FxWmiProvider.hpp" -//#include "FxWmiInstance.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 "fxioqueue.hpp" +#include "fxfileobject.hpp" +#include "fxirppreprocessinfo.hpp" +#include "fxirpdynamicdispatchinfo.hpp" -//#include "FxDpc.hpp" -#include "FxWorkItem.hpp" -#include "FxTimer.hpp" +//#include "fxdpc.hpp" +#include "fxworkitem.hpp" +#include "fxtimer.hpp" #if FX_CORE_MODE==FX_CORE_USER_MODE -#include "FxInterruptUm.hpp" -#include "FxMessageDispatchUm.hpp" +#include "fxinterruptum.hpp" +#include "fxmessagedispatchum.hpp" #else -#include "FxInterruptKm.hpp" +#include "fxinterruptkm.hpp" #endif // IO targets (device lower edge interface) -#include "FxIoTarget.hpp" -#include "FxIoTargetRemote.hpp" -#include "FxIoTargetSelf.hpp" +#include "fxiotarget.hpp" +#include "fxiotargetremote.hpp" +#include "fxiotargetself.hpp" -#include "FxUsbDevice.hpp" -#include "FxUsbInterface.hpp" -#include "FxUsbPipe.hpp" +#include "fxusbdevice.hpp" +#include "fxusbinterface.hpp" +#include "fxusbpipe.hpp" // DMA support -//#include "FxDmaEnabler.hpp" -//#include "FxDmaTransaction.hpp" -//#include "FxCommonBuffer.hpp" +//#include "fxdmaenabler.hpp" +//#include "fxdmatransaction.hpp" +//#include "fxcommonbuffer.hpp" // Triage info. -#include "wdftriage.h" +// #include "wdftriage.h" -#include "FxPkgIoShared.hpp" +#include "fxpkgioshared.hpp" #if FX_CORE_MODE==FX_CORE_USER_MODE -#include "UfxVerifier.h" +#include "ufxverifier.h" #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxobject.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxobject.hpp index a830c7d1116..a2f2af9ec90 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxobject.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxobject.hpp @@ -66,7 +66,7 @@ enum FxHandleFlags { // We cannot define FxHandleValueMask as an enumerant in FxHandleFlags because // an enum is limited to sizeof(ULONG), which doesn't work for us on a 64 bit OS // -extern __declspec(selectany) const ULONG_PTR FxHandleValueMask = (~((ULONG_PTR) FxHandleFlagMask)); +extern DECLSPEC_SELECTANY const ULONG_PTR FxHandleValueMask = (~((ULONG_PTR) FxHandleFlagMask)); // // The type itself is aligned, but the pointer is not b/c those interested in the @@ -114,7 +114,7 @@ struct FxQueryInterfaceParams { // 1) have its size rounded up to an alignment value // 2) extra size and context header appended to the allocation // -enum FxObjectType { +enum FxObjectType : UINT32 { FxObjectTypeInvalid = 0, FxObjectTypeInternal, FxObjectTypeExternal, diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgfdo.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgfdo.hpp index 6d689bf435c..c6e6c39a448 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgfdo.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgfdo.hpp @@ -467,6 +467,7 @@ protected: _Must_inspect_result_ static NTSTATUS + STDCALL _PnpFilteredStartDeviceCompletionRoutine( __in MdDeviceObject DeviceObject, __inout MdIrp Irp, @@ -476,6 +477,7 @@ protected: _Must_inspect_result_ static NTSTATUS + STDCALL _PnpStartDeviceCompletionRoutine( __in MdDeviceObject DeviceObject, __inout MdIrp Irp, diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkggeneral.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkggeneral.hpp index a28f42e158c..3116cefd5e1 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkggeneral.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkggeneral.hpp @@ -26,7 +26,7 @@ Revision History: #ifndef _FXPKGGENERAL_H_ #define _FXPKGGENERAL_H_ -#include "FxFileObjectCallbacks.hpp" +#include "fxfileobjectcallbacks.hpp" class FxShutDown : public FxCallback { diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgio.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgio.hpp index 41bcec1fa78..6557f3e917b 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgio.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgio.hpp @@ -28,10 +28,10 @@ Revision History: -#include "FxPkgIoShared.hpp" -#include "FxIrpDynamicDispatchInfo.hpp" -#include "FxDeviceCallbacks.hpp" -#include "FxCxDeviceInfo.hpp" +#include "fxpkgioshared.hpp" +#include "fxirpdynamicdispatchinfo.hpp" +#include "fxdevicecallbacks.hpp" +#include "fxcxdeviceinfo.hpp" // // This flag is or-ed with a pointer value that is ptr aligned, only lower 2 bits are available. diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpdo.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpdo.hpp index 74da9ae19fd..000c6950e6a 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpdo.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpdo.hpp @@ -284,6 +284,7 @@ private: static VOID + STDCALL _QueryCapsWorkItem( __in MdDeviceObject DeviceObject, __in PVOID Context @@ -574,6 +575,7 @@ private: static VOID + STDCALL _RemoveAndReenumerateSelf( __in PVOID Context ); diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpnp.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpnp.hpp index c8a79ca07f5..089aa87a8f2 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpnp.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpnp.hpp @@ -76,9 +76,9 @@ enum FxStateMachineDeviceType { // @@SMVERIFY_SPLIT_END -#include "FxPnpCallbacks.hpp" +#include "fxpnpcallbacks.hpp" -#include "FxEventQueue.hpp" +#include "fxeventqueue.hpp" // // Bit-flags for tracking which callback is currently executing. @@ -119,11 +119,11 @@ typedef struct _POWER_THREAD_INTERFACE { // be instantiated only in drivers which are the power policy owners // for their device stacks, which usually amounts to the being the FDO. // -#include "FxPnpStateMachine.hpp" -#include "FxPowerStateMachine.hpp" -#include "FxPowerPolicyStateMachine.hpp" +#include "fxpnpstatemachine.hpp" +#include "fxpowerstatemachine.hpp" +#include "fxpowerpolicystatemachine.hpp" -#include "FxSelfManagedIoStateMachine.hpp" +#include "fxselfmanagediostatemachine.hpp" // // Group these here instead of in the individual headers because, for some reason, @@ -425,6 +425,11 @@ struct FxPowerCaps { ULONG D3Latency; }; +enum FxWmiInstanceAction : UINT32 { + AddInstance, + RemoveInstance +}; + struct FxEnumerationInfo : public FxStump { public: FxEnumerationInfo( @@ -1732,37 +1737,37 @@ protected: static WDF_DEVICE_POWER_STATE - FxPkgPnp::PowerUpFailedDerefParentNP( + PowerUpFailedDerefParentNP( __inout FxPkgPnp* This ); static WDF_DEVICE_POWER_STATE - FxPkgPnp::PowerUpFailedNP( + PowerUpFailedNP( __inout FxPkgPnp* This ); static WDF_DEVICE_POWER_STATE - FxPkgPnp::PowerNotifyingD0ExitToWakeInterrupts( + PowerNotifyingD0ExitToWakeInterrupts( __inout FxPkgPnp* This ); static WDF_DEVICE_POWER_STATE - FxPkgPnp::PowerNotifyingD0EntryToWakeInterrupts( + PowerNotifyingD0EntryToWakeInterrupts( __inout FxPkgPnp* This ); static WDF_DEVICE_POWER_STATE - FxPkgPnp::PowerNotifyingD0ExitToWakeInterruptsNP( + PowerNotifyingD0ExitToWakeInterruptsNP( __inout FxPkgPnp* This ); static WDF_DEVICE_POWER_STATE - FxPkgPnp::PowerNotifyingD0EntryToWakeInterruptsNP( + PowerNotifyingD0EntryToWakeInterruptsNP( __inout FxPkgPnp* This ); @@ -3953,12 +3958,14 @@ private: static VOID + STDCALL _PowerThreadInterfaceReference( __inout PVOID Context ); static VOID + STDCALL _PowerThreadInterfaceDereference( __inout PVOID Context ); diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpowerpolicystatemachine.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpowerpolicystatemachine.hpp index 2574dee0005..72693bf950d 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpowerpolicystatemachine.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpowerpolicystatemachine.hpp @@ -4,8 +4,8 @@ #ifndef _FXPOWERPOLICYSTATEMACHINE_H_ #define _FXPOWERPOLICYSTATEMACHINE_H_ -#include "FxPowerIdleStateMachine.hpp" -#include "FxPoxInterface.hpp" +#include "fxpoweridlestatemachine.hpp" +#include "fxpoxinterface.hpp" // @@SMVERIFY_SPLIT_BEGIN // diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpowerstatemachine.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpowerstatemachine.hpp index 23d7332af0a..c1b9cb2ad3e 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpowerstatemachine.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpowerstatemachine.hpp @@ -44,7 +44,7 @@ enum FxPowerEvent { // PowerSingularEventMask = PowerParentToD0, - PowerEventMaximum = 0xFFFFFFFF, + PowerEventMaximum = 0xFFFF, }; union FxPowerStateInfo { diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpoxinterface.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpoxinterface.hpp index 6da5496779e..38a3f556b6f 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxpoxinterface.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxpoxinterface.hpp @@ -4,7 +4,7 @@ #ifndef _FXPOXINTERFACE_H_ #define _FXPOXINTERFACE_H_ -#include "FxDevicePwrReqStateMachine.hpp" +#include "fxdevicepwrreqstatemachine.hpp" class FxPoxInterface { diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxrelateddevicelist.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxrelateddevicelist.hpp index 77ac388f5c3..76040e043e6 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxrelateddevicelist.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxrelateddevicelist.hpp @@ -19,7 +19,7 @@ public: __in PFX_DRIVER_GLOBALS FxDriverGlobals ) { - __super::LockForEnum(FxDriverGlobals); + FxSpinLockTransactionedList::LockForEnum(FxDriverGlobals); // __super call } VOID @@ -27,7 +27,7 @@ public: __in PFX_DRIVER_GLOBALS FxDriverGlobals ) { - __super::UnlockFromEnum(FxDriverGlobals); + FxSpinLockTransactionedList::UnlockFromEnum(FxDriverGlobals); // __super call } _Must_inspect_result_ @@ -109,4 +109,4 @@ public: ULONG m_NeedReportMissing; }; -#endif _FXRELATEDDEVICELIST_H_ +#endif // _FXRELATEDDEVICELIST_H_ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequest.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequest.hpp index 76d2a92545e..e2197c22729 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequest.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequest.hpp @@ -639,7 +639,7 @@ protected: ); #if DBG - FxRequest::~FxRequest( + ~FxRequest( VOID ); #endif // DBG @@ -1300,7 +1300,7 @@ public: ASSERT(m_ForwardRequestToParent == FALSE); - __super::ClearFieldsForReuse(); + FxRequestBase::ClearFieldsForReuse(); // __super call } virtual diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbase.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbase.hpp index fdcd510150f..4afc7c4daf6 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbase.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbase.hpp @@ -30,7 +30,9 @@ Revision History: #ifndef _FXREQUESTBASE_H_ #define _FXREQUESTBASE_H_ -#include "FxRequestCallbacks.hpp" +#include "fxrequestcallbacks.hpp" + +#define WDF_REQUEST_REUSE_MUST_COMPLETE 2 // @@ -293,6 +295,7 @@ public: } __inline + BOOLEAN HasContext( VOID ) @@ -690,7 +693,7 @@ public: VOID ); - __declspec(noreturn) + DECLSPEC_NORETURN VOID FatalError( __in NTSTATUS Status @@ -950,9 +953,9 @@ protected: }; #if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE)) -#include "FxRequestBaseKm.hpp" -#else if ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) -#include "FxRequestBaseUm.hpp" +#include "fxrequestbasekm.hpp" +#elif ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) +#include "fxrequestbaseum.hpp" #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbuffer.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbuffer.hpp index 15cd88f0e39..0690816a41a 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbuffer.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbuffer.hpp @@ -148,9 +148,9 @@ public: }; #if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE)) -#include "FxRequestBufferKm.hpp" -#else if ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) -#include "FxRequestBufferUm.hpp" +#include "fxrequestbufferkm.hpp" +#elif ((FX_CORE_MODE)==(FX_CORE_USER_MODE)) +#include "fxrequestbufferum.hpp" #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxsyncrequest.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxsyncrequest.hpp index ed40730c44e..9bdd16822f9 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxsyncrequest.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxsyncrequest.hpp @@ -71,7 +71,7 @@ protected: ASSERTMSG("FxSyncRequest::operator new called, should only be" " declared on the stack\n", FALSE); - return NULL; + return (PVOID)1; } public: @@ -81,7 +81,7 @@ public: VOID ) { - NTSTATUS status; + NTSTATUS status = STATUS_SUCCESS; #if (FX_CORE_MODE == FX_CORE_USER_MODE) // @@ -118,4 +118,4 @@ public: BOOLEAN m_ClearContextOnDestroy; }; -#endif _FXSYNCREQUEST_H_ +#endif // _FXSYNCREQUEST_H_ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemthread.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemthread.hpp index a0237181929..ba2ed062e4b 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemthread.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemthread.hpp @@ -256,6 +256,7 @@ private: // static VOID + STDCALL StaticThreadThunk( __inout PVOID Context ); @@ -281,6 +282,7 @@ private: // static VOID + STDCALL StaticReaperThunk( __inout PVOID Context ); diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemworkitem.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemworkitem.hpp index b1a428b2676..b2fcf015084 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemworkitem.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemworkitem.hpp @@ -130,7 +130,7 @@ public: break; default: - return __super::QueryInterface(Params); + return FxNonPagedObject::QueryInterface(Params); // __super call } return STATUS_SUCCESS; diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxtelemetry.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxtelemetry.hpp index 7759bd8d663..21017675658 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxtelemetry.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxtelemetry.hpp @@ -28,19 +28,19 @@ Notes: #pragma once #include -#include "FxTelemetryCommon.hpp" +#include "fxtelemetrycommon.hpp" #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) -#include "FxTelemetryKm.hpp" +#include "fxtelemetrykm.hpp" #else -#include "FxTelemetryUm.hpp" +#include "fxtelemetryum.hpp" #endif #if defined(__cplusplus) extern "C" { #endif -TRACELOGGING_DECLARE_PROVIDER(g_TelemetryProvider); +// TRACELOGGING_DECLARE_PROVIDER(g_TelemetryProvider); __REACTOS__ #define FX_TELEMETRY_ENABLED(TraceHandle, Globals) \ (TraceHandle && IsDriverTelemetryContextInitialized(Globals)) \ diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxtelemetrycommon.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxtelemetrycommon.hpp index 7fa35e5f1b7..0f7f9733d3b 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxtelemetrycommon.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxtelemetrycommon.hpp @@ -33,8 +33,8 @@ Notes: // MmGetSystemRoutineAddress. This allows our code to be backwards compatible to Win7 // #define TLG_HAVE_EVENT_SET_INFORMATION 2 -#include -#include +// #include +// #include // WDF01000.sys #define KMDF_FX_TRACE_LOGGING_PROVIDER_NAME "Microsoft.Wdf.KMDF.Fx" diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxtransactionedlist.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxtransactionedlist.hpp index 7c096c58124..903ba346690 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxtransactionedlist.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxtransactionedlist.hpp @@ -274,7 +274,9 @@ public: __inline NTSTATUS +#ifdef _MSC_VER #pragma prefast(suppress:__WARNING_UNMATCHED_DEFN, "_Must_inspect_result_ not needed in kernel mode as the function always succeeds"); +#endif Initialize( VOID ) diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxtypedefs.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxtypedefs.hpp index 42eddecd320..8f1811a0f2c 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxtypedefs.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxtypedefs.hpp @@ -31,11 +31,11 @@ Revision History: #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) -#include "fxtypedefsKm.hpp" +#include "fxtypedefskm.hpp" #else -#include "fxtypedefsUm.hpp" +#include "fxtypedefsum.hpp" #endif diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbdevice.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbdevice.hpp index 5890cbfae16..72a2e8d9aa9 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbdevice.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbdevice.hpp @@ -21,7 +21,7 @@ Revision History: #ifndef _FXUSBDEVICE_H_ #define _FXUSBDEVICE_H_ -#include "FxUsbRequestContext.hpp" +#include "fxusbrequestcontext.hpp" typedef enum _FX_URB_TYPE : UCHAR { FxUrbTypeLegacy, @@ -214,6 +214,7 @@ public: ); __inline + VOID CopyDeviceDescriptor( __out PUSB_DEVICE_DESCRIPTOR UsbDeviceDescriptor ) @@ -449,7 +450,9 @@ public: PURB* Urb ); +#ifdef _MSC_VER #pragma warning(disable:28285) +#endif __checkReturn NTSTATUS CreateIsochUrb( diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbidleinfo.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbidleinfo.hpp index 55554915a52..b6c7529054d 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbidleinfo.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbidleinfo.hpp @@ -37,6 +37,7 @@ private: __drv_maxIRQL(PASSIVE_LEVEL) static VOID + STDCALL _UsbIdleCallback( __in PVOID Context ); diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbinterface.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbinterface.hpp index b9596a8ba1e..8088a64d860 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbinterface.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbinterface.hpp @@ -6,10 +6,10 @@ extern "C" { #include -#include +#include } -#include "FxUsbRequestContext.hpp" +#include "fxusbrequestcontext.hpp" #define FX_USB_INTERFACE_TAG 'uItG' //using a random uniqure value diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbpipe.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbpipe.hpp index 6ddf6e81289..46f8e3599ee 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbpipe.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbpipe.hpp @@ -4,8 +4,8 @@ #ifndef _FXUSBPIPE_H_ #define _FXUSBPIPE_H_ -#include "FxUsbRequestContext.hpp" -#include "FxUsbInterface.hpp" +#include "fxusbrequestcontext.hpp" +#include "fxusbinterface.hpp" // // Technically, EHCI can support 4MB, but the usb driver stack doesn't diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbrequestcontext.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbrequestcontext.hpp index 8c560b5313c..e871e013b3a 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbrequestcontext.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxusbrequestcontext.hpp @@ -48,7 +48,7 @@ struct FxUsbRequestContext : public FxRequestContext { ) { m_UsbParameters.UsbdStatus = GetUsbdStatus(); - __super::CopyParameters(Request); + FxRequestContext::CopyParameters(Request); // __super call } VOID diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxuserobject.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxuserobject.hpp index 43372110423..a0b303a3213 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxuserobject.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxuserobject.hpp @@ -63,7 +63,7 @@ public: break; default: - return __super::QueryInterface(Params); + return FxNonPagedObject::QueryInterface(Params); // __super call } return STATUS_SUCCESS; diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxverifier.h b/sdk/lib/drivers/wdf/shared/inc/private/common/fxverifier.h index 5cfd5916714..3bed5a1422b 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxverifier.h +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxverifier.h @@ -137,8 +137,8 @@ IsFxVerifierFunctionTableHooking( } } +DECLSPEC_NORETURN VOID -__declspec(noreturn) FxVerifierBugCheckWorker( __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDF_BUGCHECK_CODES WdfBugCheckCode, @@ -146,8 +146,8 @@ FxVerifierBugCheckWorker( __in_opt ULONG_PTR BugCheckParameter3 = 0 ); +DECLSPEC_NORETURN VOID -__declspec(noreturn) FxVerifierNullBugCheck( __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PVOID ReturnAddress diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxverifierlock.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxverifierlock.hpp index 2ed37f863fe..6c5457c3565 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxverifierlock.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxverifierlock.hpp @@ -157,7 +157,7 @@ extern "C" { #define FX_CALLBACKLOCK_ORDER_PACKAGE 0x30 #define FX_CALLBACKLOCK_ORDER_QUEUE 0x31 -#define FX_VERIFIER_LOCK_ENTRY(FX_OBJECT_TYPE, FX_LOCK_ORDER) { ##FX_OBJECT_TYPE, ##FX_LOCK_ORDER } +#define FX_VERIFIER_LOCK_ENTRY(FX_OBJECT_TYPE, FX_LOCK_ORDER) { FX_OBJECT_TYPE, FX_LOCK_ORDER } // Internal FxLock spinlock entries #define FX_VERIFIER_LOCK_ENTRIES() \ @@ -303,7 +303,7 @@ private: ); void - FxVerifierLock::FxVerifierLockDumpDetails( + FxVerifierLockDumpDetails( __in FxVerifierLock* Lock, __in PVOID curThread, __in FxVerifierLock* PerThreadList diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxwaitlock.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxwaitlock.hpp index 2d854fbf1da..782bc04eb24 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxwaitlock.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxwaitlock.hpp @@ -337,7 +337,7 @@ public: Initialize( ) { - return __super::Initialize(); + return FxWaitLockInternal::Initialize(); // __super call } FxWaitLock( diff --git a/sdk/lib/drivers/wdf/shared/inc/private/common/fxwakeinterruptstatemachine.hpp b/sdk/lib/drivers/wdf/shared/inc/private/common/fxwakeinterruptstatemachine.hpp index 13f2711bc54..125683adf79 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/common/fxwakeinterruptstatemachine.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/common/fxwakeinterruptstatemachine.hpp @@ -11,7 +11,7 @@ // const UCHAR FxWakeInterruptEventQueueDepth = 8; -enum FxWakeInterruptEvents { +enum FxWakeInterruptEvents : UINT32 { WakeInterruptEventInvalid = 0x00, WakeInterruptEventIsr = 0x01, WakeInterruptEventEnteringD0 = 0x02, diff --git a/sdk/lib/drivers/wdf/shared/inc/private/km/fxdmaenabler.hpp b/sdk/lib/drivers/wdf/shared/inc/private/km/fxdmaenabler.hpp index 5bdb39fec0d..5e28402d5e0 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/km/fxdmaenabler.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/km/fxdmaenabler.hpp @@ -24,7 +24,7 @@ Revision History: #ifndef __FX_DMA_ENABLER_HPP__ #define __FX_DMA_ENABLER_HPP__ -#include "FxDmaEnablerCallbacks.hpp" +#include "fxdmaenablercallbacks.hpp" // // Dma Description structure diff --git a/sdk/lib/drivers/wdf/shared/inc/private/km/fxglobalskm.h b/sdk/lib/drivers/wdf/shared/inc/private/km/fxglobalskm.h index 0b4ed6e61cc..dbe65de0b4a 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/km/fxglobalskm.h +++ b/sdk/lib/drivers/wdf/shared/inc/private/km/fxglobalskm.h @@ -250,6 +250,7 @@ VOID ); typedef +VOID (*PFN_POX_ACTIVATE_COMPONENT) ( __in POHANDLE Handle, __in ULONG Component, @@ -257,6 +258,7 @@ typedef ); typedef +VOID (*PFN_POX_IDLE_COMPONENT) ( __in POHANDLE Handle, __in ULONG Component, @@ -456,7 +458,7 @@ private: } FX_DRIVER_TRACKER_CACHE_AWARE, *PFX_DRIVER_TRACKER_CACHE_AWARE; -#include "FxGlobals.h" +#include "fxglobals.h" // diff --git a/sdk/lib/drivers/wdf/shared/inc/private/km/fxinterruptkm.hpp b/sdk/lib/drivers/wdf/shared/inc/private/km/fxinterruptkm.hpp index 6150820e5c8..cd878c37307 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/km/fxinterruptkm.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/km/fxinterruptkm.hpp @@ -27,7 +27,7 @@ Revision History: #ifndef _FXINTERRUPTKM_H_ #define _FXINTERRUPTKM_H_ -#include "FxInterrupt.hpp" +#include "fxinterrupt.hpp" __inline struct _KINTERRUPT* diff --git a/sdk/lib/drivers/wdf/shared/inc/private/km/fxiotargetkm.hpp b/sdk/lib/drivers/wdf/shared/inc/private/km/fxiotargetkm.hpp index 8707fe9a82d..edfba820250 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/km/fxiotargetkm.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/km/fxiotargetkm.hpp @@ -127,7 +127,7 @@ FxIoContext::ReleaseAndRestore( // // Release the other buffer and all __super related fields // - __super::ReleaseAndRestore(Request); + FxRequestContext::ReleaseAndRestore(Request); // __super call } __inline diff --git a/sdk/lib/drivers/wdf/shared/inc/private/km/fxirpkm.hpp b/sdk/lib/drivers/wdf/shared/inc/private/km/fxirpkm.hpp index 6cdbe8e451d..bd88ce6b202 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/km/fxirpkm.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/km/fxirpkm.hpp @@ -53,7 +53,7 @@ VOID __in PVOID CancelContext ); -#include "FxIrp.hpp" +#include "fxirp.hpp" @@ -66,6 +66,17 @@ FxIrp::GetIrp( return m_Irp; } +__inline +MdIrp +FxIrp::SetIrp( + MdIrp irp + ) +{ + MdIrp old = m_Irp; + m_Irp = irp; + return old; +} + __inline VOID FxIrp::CompleteRequest( @@ -174,6 +185,7 @@ FxIrp::SetCancelRoutine( __inline NTSTATUS +STDCALL FxIrp::_IrpSynchronousCompletion( __in MdDeviceObject DeviceObject, __in PIRP OriginalIrp, diff --git a/sdk/lib/drivers/wdf/shared/inc/private/km/fxperftracekm.hpp b/sdk/lib/drivers/wdf/shared/inc/private/km/fxperftracekm.hpp index 5d495d3ca48..7d0dac55a3c 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/km/fxperftracekm.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/km/fxperftracekm.hpp @@ -33,29 +33,31 @@ Notes: #define WDF_INTERRUPT_EVENT_VERSION_2 2 #define WDF_WORK_ITEM_EVENT_VERSION_2 2 +// __REACTOS__ : functions are commented out + FORCEINLINE VOID FxPerfTraceDpc( _In_ PVOID DriverCallback ) { - PWMI_WDF_NOTIFY_ROUTINE perfTraceCallback = NULL; + // PWMI_WDF_NOTIFY_ROUTINE perfTraceCallback = NULL; - // - // Trace driver's ISR using perf trace callback. If the perf trace callback - // is NULL, it means either perf tracing is not enabled, or this OS - // doesn't support perf tracing for WDF (note only win8+ supports WDF perf - // trace callbacks). - // - perfTraceCallback = FxLibraryGlobals.PerfTraceRoutines->DpcNotifyRoutine; - if (perfTraceCallback != NULL) { - (perfTraceCallback) (DriverCallback, // event data - sizeof(PVOID), // sizeof event - PERF_WDF_DPC, // group mask - PERFINFO_LOG_TYPE_WDF_DPC, // hook id - WDF_DPC_EVENT_VERSION_2 // version - ); - } + // // + // // Trace driver's ISR using perf trace callback. If the perf trace callback + // // is NULL, it means either perf tracing is not enabled, or this OS + // // doesn't support perf tracing for WDF (note only win8+ supports WDF perf + // // trace callbacks). + // // + // perfTraceCallback = FxLibraryGlobals.PerfTraceRoutines->DpcNotifyRoutine; + // if (perfTraceCallback != NULL) { + // (perfTraceCallback) (DriverCallback, // event data + // sizeof(PVOID), // sizeof event + // PERF_WDF_DPC, // group mask + // PERFINFO_LOG_TYPE_WDF_DPC, // hook id + // WDF_DPC_EVENT_VERSION_2 // version + // ); + // } } FORCEINLINE @@ -64,17 +66,17 @@ FxPerfTraceInterrupt( _In_ PVOID DriverCallback ) { - PWMI_WDF_NOTIFY_ROUTINE perfTraceCallback = NULL; + // PWMI_WDF_NOTIFY_ROUTINE perfTraceCallback = NULL; - perfTraceCallback = FxLibraryGlobals.PerfTraceRoutines->InterruptNotifyRoutine; - if (perfTraceCallback != NULL) { - (perfTraceCallback) (DriverCallback, // event data - sizeof(PVOID), // sizeof event - PERF_WDF_INTERRUPT, // group mask - PERFINFO_LOG_TYPE_WDF_INTERRUPT, // hook id - WDF_INTERRUPT_EVENT_VERSION_2 // version - ); - } + // perfTraceCallback = FxLibraryGlobals.PerfTraceRoutines->InterruptNotifyRoutine; + // if (perfTraceCallback != NULL) { + // (perfTraceCallback) (DriverCallback, // event data + // sizeof(PVOID), // sizeof event + // PERF_WDF_INTERRUPT, // group mask + // PERFINFO_LOG_TYPE_WDF_INTERRUPT, // hook id + // WDF_INTERRUPT_EVENT_VERSION_2 // version + // ); + // } } FORCEINLINE @@ -83,17 +85,17 @@ FxPerfTracePassiveInterrupt( _In_ PVOID DriverCallback ) { - PWMI_WDF_NOTIFY_ROUTINE perfTraceCallback = NULL; + // PWMI_WDF_NOTIFY_ROUTINE perfTraceCallback = NULL; - perfTraceCallback = FxLibraryGlobals.PerfTraceRoutines->InterruptNotifyRoutine; - if (perfTraceCallback != NULL) { - (perfTraceCallback) (DriverCallback, - sizeof(PVOID), - PERF_WDF_INTERRUPT, - PERFINFO_LOG_TYPE_WDF_PASSIVE_INTERRUPT, - WDF_INTERRUPT_EVENT_VERSION_2 - ); - } + // perfTraceCallback = FxLibraryGlobals.PerfTraceRoutines->InterruptNotifyRoutine; + // if (perfTraceCallback != NULL) { + // (perfTraceCallback) (DriverCallback, + // sizeof(PVOID), + // PERF_WDF_INTERRUPT, + // PERFINFO_LOG_TYPE_WDF_PASSIVE_INTERRUPT, + // WDF_INTERRUPT_EVENT_VERSION_2 + // ); + // } } FORCEINLINE @@ -102,16 +104,16 @@ FxPerfTraceWorkItem( _In_ PVOID DriverCallback ) { - PWMI_WDF_NOTIFY_ROUTINE perfTraceCallback = NULL; + // PWMI_WDF_NOTIFY_ROUTINE perfTraceCallback = NULL; - perfTraceCallback = FxLibraryGlobals.PerfTraceRoutines->WorkItemNotifyRoutine; - if (perfTraceCallback != NULL) { - (perfTraceCallback) (DriverCallback, - sizeof(PVOID), - PERF_WORKER_THREAD, - PERFINFO_LOG_TYPE_WDF_WORK_ITEM, - WDF_WORK_ITEM_EVENT_VERSION_2 - ); - } + // perfTraceCallback = FxLibraryGlobals.PerfTraceRoutines->WorkItemNotifyRoutine; + // if (perfTraceCallback != NULL) { + // (perfTraceCallback) (DriverCallback, + // sizeof(PVOID), + // PERF_WORKER_THREAD, + // PERFINFO_LOG_TYPE_WDF_WORK_ITEM, + // WDF_WORK_ITEM_EVENT_VERSION_2 + // ); + // } } diff --git a/sdk/lib/drivers/wdf/shared/inc/private/um/fxiotargetum.hpp b/sdk/lib/drivers/wdf/shared/inc/private/um/fxiotargetum.hpp index faa02a582dc..416ef5f28ce 100644 --- a/sdk/lib/drivers/wdf/shared/inc/private/um/fxiotargetum.hpp +++ b/sdk/lib/drivers/wdf/shared/inc/private/um/fxiotargetum.hpp @@ -66,7 +66,7 @@ FxIoContext::ReleaseAndRestore( // // Release the other buffer and all __super related fields // - __super::ReleaseAndRestore(Request); + FxRequestContext::ReleaseAndRestore(Request); // __super call } __inline diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/default/fxdefaultirphandler.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/default/fxdefaultirphandler.cpp index 517cb0cfea3..33b5b818be1 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/default/fxdefaultirphandler.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/default/fxdefaultirphandler.cpp @@ -34,10 +34,10 @@ Revision History: extern "C" { #include "mx.h" } -#include "FxMin.hpp" +#include "fxmin.hpp" extern "C" { -#include "FxDefaultIrpHandler.tmh" +// #include "FxDefaultIrpHandler.tmh" } FxDefaultIrpHandler::FxDefaultIrpHandler( diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/general/fxpkggeneral.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/general/fxpkggeneral.cpp index 61a8e356dd3..80e144aabfa 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/general/fxpkggeneral.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/general/fxpkggeneral.cpp @@ -34,10 +34,10 @@ Revision History: extern "C" { #include "mx.h" } -#include "FxMin.hpp" +#include "fxmin.hpp" extern "C" { -#include "FxPkgGeneral.tmh" +// #include "FxPkgGeneral.tmh" } diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/io/fxioqueue.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/io/fxioqueue.cpp index 2989c5be3b3..9d61e918e26 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/io/fxioqueue.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/io/fxioqueue.cpp @@ -23,7 +23,7 @@ Revision History: --*/ #include "ioprivshared.hpp" -#include "FxIoQueue.hpp" +#include "fxioqueue.hpp" extern "C" { #if defined(EVENT_TRACING) @@ -561,7 +561,7 @@ Returns: // End: - __super::Dispose(); + FxNonPagedObject::Dispose(); // __super call return TRUE; } @@ -6334,7 +6334,7 @@ Routine Description: return; } -__declspec(noreturn) +DECLSPEC_NORETURN VOID FxIoQueue::FatalError( __in NTSTATUS Status diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/io/fxioqueueapi.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/io/fxioqueueapi.cpp index 4dafca90e4f..8c277e8fe48 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/io/fxioqueueapi.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/io/fxioqueueapi.cpp @@ -21,11 +21,11 @@ Revision History: --*/ #include "ioprivshared.hpp" -#include "FxPkgIo.hpp" -#include "FxIoQueue.hpp" +#include "fxpkgio.hpp" +#include "fxioqueue.hpp" extern "C" { -#include "FxIoQueueApi.tmh" +// #include "FxIoQueueApi.tmh" } // @@ -49,6 +49,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -249,6 +250,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) WDF_IO_QUEUE_STATE +STDCALL WDFEXPORT(WdfIoQueueGetState)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -297,6 +299,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) WDFDEVICE +STDCALL WDFEXPORT(WdfIoQueueGetDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -333,6 +336,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueueStart)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -379,6 +383,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueueStop)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -435,6 +440,7 @@ Returns: __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueueStopSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -486,6 +492,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueueStopAndPurge)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -548,6 +555,7 @@ Returns: __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueueStopAndPurgeSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -605,6 +613,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueRetrieveNextRequest)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -673,6 +682,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueRetrieveRequestByFileObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -766,6 +776,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueRetrieveFoundRequest)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -864,6 +875,7 @@ Returns: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueFindRequest)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1064,6 +1076,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueueDrain)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1115,6 +1128,7 @@ WDFEXPORT(WdfIoQueueDrain)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueueDrainSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1160,6 +1174,7 @@ WDFEXPORT(WdfIoQueueDrainSynchronously)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueuePurgeSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1208,6 +1223,7 @@ WDFEXPORT(WdfIoQueuePurgeSynchronously)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoQueuePurge)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1270,6 +1286,7 @@ WDFEXPORT(WdfIoQueuePurge)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueReadyNotify)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1318,6 +1335,7 @@ WDFEXPORT(WdfIoQueueReadyNotify)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoQueueAssignForwardProgressPolicy)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/io/fxpkgio.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/io/fxpkgio.cpp index 5b09c0167b3..af17a46e556 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/io/fxpkgio.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/io/fxpkgio.cpp @@ -159,7 +159,6 @@ FX_VF_METHOD(FxPkgIo, VerifyDispatchContext) ( return status; } -__inline _Must_inspect_result_ NTSTATUS __fastcall @@ -190,7 +189,7 @@ Return Value: NTSTATUS status; FxIrp fxIrp(Irp); - ASSERT(((UCHAR)DispatchContext & FX_IN_DISPATCH_CALLBACK) == 0); + ASSERT(((UCHAR)(ULONG_PTR)DispatchContext & FX_IN_DISPATCH_CALLBACK) == 0); ASSERT(fxIrp.GetMajorFunction() <= IRP_MJ_MAXIMUM_FUNCTION); @@ -236,7 +235,7 @@ Return Value: // Advance to next node. // DispatchContext = (WDFCONTEXT)(((PLIST_ENTRY)DispatchContext)->Flink); - ASSERT(((UCHAR)DispatchContext & FX_IN_DISPATCH_CALLBACK) == 0); + ASSERT(((UCHAR)(ULONG_PTR)DispatchContext & FX_IN_DISPATCH_CALLBACK) == 0); ASSERT(fxIrp.GetMajorFunction() == IRP_MJ_READ || fxIrp.GetMajorFunction() == IRP_MJ_WRITE || @@ -337,7 +336,6 @@ CompleteIrp: return status; } -__inline _Must_inspect_result_ NTSTATUS __fastcall diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/io/ioprivshared.hpp b/sdk/lib/drivers/wdf/shared/irphandlers/io/ioprivshared.hpp index 5167f1dd373..bbcdf41d7b2 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/io/ioprivshared.hpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/io/ioprivshared.hpp @@ -34,7 +34,7 @@ Revision History: #endif /*#if defined(MODE_AGNSOTIC_FXPKGIO_NOT_IN_SHARED_FOLDER) -#include +#include #else // common header file for all irphandler\* files #include "irphandlerspriv.hpp" @@ -50,18 +50,18 @@ extern "C" { #include "mx.h" } -#include "FxMin.hpp" +#include "fxmin.hpp" #include "wdfmemory.h" #include "wdfrequest.h" #include "wdfio.h" #include "wdfdevice.h" -#include "wdfWmi.h" -#include "wdfChildList.h" +#include "wdfwmi.h" +#include "wdfchildlist.h" #include "wdfpdo.h" #include "wdffdo.h" -#include "FxIrpQueue.hpp" -#include "FxCallback.hpp" +#include "fxirpqueue.hpp" +#include "fxcallback.hpp" // __drv_functionClass(EVT_SYSTEMWORKITEM) @@ -78,41 +78,41 @@ typedef EVT_SYSTEMWORKITEM *PFN_WDF_SYSTEMWORKITEM; // -#include "FxSystemThread.hpp" +#include "fxsystemthread.hpp" -#include "FxCallbackSpinlock.hpp" -#include "FxCallbackMutexLock.hpp" -#include "FxTransactionedList.hpp" +#include "fxcallbackspinlock.hpp" +#include "fxcallbackmutexlock.hpp" +#include "fxtransactionedlist.hpp" #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) -#include "FxIrpKm.hpp" +#include "fxirpkm.hpp" #else -#include "FxIrpUm.hpp" +#include "fxirpum.hpp" #endif -#include "FxPackage.hpp" -#include "FxCollection.hpp" -#include "FxDeviceInitShared.hpp" -#include "FxDeviceToMxInterface.hpp" +#include "fxpackage.hpp" +#include "fxcollection.hpp" +#include "fxdeviceinitshared.hpp" +#include "fxdevicetomxinterface.hpp" -#include "IfxMemory.hpp" -#include "FxCallback.hpp" -#include "FxRequestContext.hpp" -#include "FxRequestContextTypes.h" -#include "FxRequestBase.hpp" -#include "FxMemoryObject.hpp" -#include "FxMemoryBufferPreallocated.hpp" -#include "FxRequestMemory.hpp" -#include "FxRequest.hpp" -#include "FxRequestBuffer.hpp" -#include "FxSyncRequest.hpp" +#include "ifxmemory.hpp" +#include "fxcallback.hpp" +#include "fxrequestcontext.hpp" +#include "fxrequestcontexttypes.h" +#include "fxrequestbase.hpp" +#include "fxmemoryobject.hpp" +#include "fxmemorybufferpreallocated.hpp" +#include "fxrequestmemory.hpp" +#include "fxrequest.hpp" +#include "fxrequestbuffer.hpp" +#include "fxsyncrequest.hpp" -#include "irphandlerspriv.hpp" -#include "FxPkgPnp.hpp" -#include "FxPkgIo.hpp" -#include "FxIoQueue.hpp" -#include "FxIoQueueCallbacks.hpp" +#include "shared/irphandlers/irphandlerspriv.hpp" +#include "fxpkgpnp.hpp" +#include "fxpkgio.hpp" +#include "fxioqueue.hpp" +#include "fxioqueuecallbacks.hpp" // @@ -251,7 +251,7 @@ typedef struct _WDF_IO_QUEUE_CONFIG_V1_9 { #include "FxIoQueue.hpp" -/*#if !defined(MODE_AGNSOTIC_FXPKGIO_NOT_IN_SHARED_FOLDER) +#if !defined(MODE_AGNSOTIC_FXPKGIO_NOT_IN_SHARED_FOLDER) // // diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/io/km/fxioqueuekm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/io/km/fxioqueuekm.cpp index 514eaac3355..3e0d3488150 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/io/km/fxioqueuekm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/io/km/fxioqueuekm.cpp @@ -1,7 +1,7 @@ // // Copyright (C) Microsoft. All rights reserved. // -#include "..\ioprivshared.hpp" +#include "../ioprivshared.hpp" extern "C" { @@ -511,7 +511,7 @@ Routine Description: return status; } - RtlZeroMemory(m_FwdProgContext, sizeof(FXIO_FORWARD_PROGRESS_CONTEXT)); + *m_FwdProgContext = {}; // // Initialize the things which will not fail first diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/irphandlerspriv.hpp b/sdk/lib/drivers/wdf/shared/irphandlers/irphandlerspriv.hpp index cc43545aaaa..2d495151541 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/irphandlerspriv.hpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/irphandlerspriv.hpp @@ -26,13 +26,13 @@ extern "C" { #include "mx.h" } -#include "FxMin.hpp" +#include "fxmin.hpp" #if (FX_CORE_MODE == FX_CORE_USER_MODE) #include "wdmdefs.h" -#include "FxIrpUm.hpp" +#include "fxirpum.hpp" #else -#include "FxIrpKm.hpp" +#include "fxirpkm.hpp" #endif -#include "FxIrp.hpp" +#include "fxirp.hpp" diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/package/fxpackage.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/package/fxpackage.cpp index 341be94a690..d45768d3b94 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/package/fxpackage.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/package/fxpackage.cpp @@ -24,9 +24,9 @@ Revision History: --*/ -#include "irphandlerspriv.hpp" +#include "shared/irphandlers/irphandlerspriv.hpp" -#include "FxPackage.hpp" +#include "fxpackage.hpp" FxPackage::FxPackage( __in PFX_DRIVER_GLOBALS FxDriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fdopower.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fdopower.cpp index 93420bef7ba..09b20e0e0ac 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fdopower.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fdopower.cpp @@ -65,15 +65,12 @@ Returns: --*/ { FxPkgFdo* pThis; - MdDeviceObject pDevObj; NTSTATUS status; MdIrp pIrp; pIrp = Irp->GetIrp(); pThis = (FxPkgFdo*) This; - pDevObj = pThis->m_Device->GetDeviceObject(); - // // FDOs don't handle this IRP, so simply pass it down. // diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxinterruptapi.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxinterruptapi.cpp index 7cade6a0970..efdbc17c4e3 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxinterruptapi.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxinterruptapi.cpp @@ -27,7 +27,7 @@ Revision History: #include "pnppriv.hpp" extern "C" { -#include "FxInterruptApi.tmh" +// #include "FxInterruptApi.tmh" } // diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgfdo.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgfdo.cpp index 8a51eb63832..ec29a1a4dc9 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgfdo.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgfdo.cpp @@ -37,7 +37,7 @@ Revision History: #if defined(EVENT_TRACING) // Tracing support extern "C" { -#include "FxPkgFdo.tmh" +#include "fxpkgfdo.tmh" } #endif @@ -1525,7 +1525,7 @@ FxPkgFdo::PostCreateDeviceInitialize( { NTSTATUS status; - status = __super::PostCreateDeviceInitialize(); + status = FxPkgPnp::PostCreateDeviceInitialize(); // __super call if (!NT_SUCCESS(status)) { return status; } diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpdo.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpdo.cpp index 71bf5ef7f21..0a7fc5c3a0d 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpdo.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpdo.cpp @@ -353,7 +353,7 @@ FxPkgPdo::FinishInitialize( // Important to do this last since this will cause a pnp state machine // transition // - __super::FinishInitialize(DeviceInit); + FxPkgPnp::FinishInitialize(DeviceInit); // __super call } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpnp.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpnp.cpp index 8df92503d37..40d93c5ebce 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpnp.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpnp.cpp @@ -340,7 +340,7 @@ FxPkgPnp::Dispose( // // Call up the hierarchy // - return __super::Dispose(); + return FxPackage::Dispose(); // __super call } @@ -1754,7 +1754,7 @@ FxPkgPnp::QueryForCapabilities( // which is a safe assumption to start with, one which may be // overridden later. // - C_ASSERT(PowerDeviceD0 == DeviceWakeDepthD0); + C_ASSERT(PowerDeviceD0 == static_cast(DeviceWakeDepthD0)); m_DeviceWake[i - PowerSystemWorking] = (BYTE) caps.DeviceCaps.DeviceWake; } } @@ -2741,35 +2741,37 @@ FxPkgPnp::RegisterPowerPolicyWmiInstance( __out FxWmiInstanceInternal** Instance ) { - WDF_WMI_PROVIDER_CONFIG config; - NTSTATUS status; + // WDF_WMI_PROVIDER_CONFIG config; + // NTSTATUS status; - WDF_WMI_PROVIDER_CONFIG_INIT(&config, Guid); + // WDF_WMI_PROVIDER_CONFIG_INIT(&config, Guid); + // // + // // We are assuming we are registering either for the wait wake or device + // // timeout GUIDs which both operate on BOOLEANs. If we expand this API in + // // the future, have the caller pass in a config structure for the provider + // // GUID. + // // + // config.MinInstanceBufferSize = sizeof(BOOLEAN); + + // status = m_Device->m_PkgWmi->AddPowerPolicyProviderAndInstance( + // &config, + // Callbacks, + // Instance); + + // if (status == STATUS_OBJECT_NAME_COLLISION) { + // status = STATUS_SUCCESS; + // } + + // if (!NT_SUCCESS(status)) { + // DoTraceLevelMessage( + // GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, + // "Failed to register WMI power GUID %!STATUS!", status); + // } // - // We are assuming we are registering either for the wait wake or device - // timeout GUIDs which both operate on BOOLEANs. If we expand this API in - // the future, have the caller pass in a config structure for the provider - // GUID. - // - config.MinInstanceBufferSize = sizeof(BOOLEAN); - - status = m_Device->m_PkgWmi->AddPowerPolicyProviderAndInstance( - &config, - Callbacks, - Instance); - - if (status == STATUS_OBJECT_NAME_COLLISION) { - status = STATUS_SUCCESS; - } - - if (!NT_SUCCESS(status)) { - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, - "Failed to register WMI power GUID %!STATUS!", status); - } - - return status; + // return status; + ROSWDFNOTIMPLEMENTED; + return STATUS_SUCCESS; } NTSTATUS @@ -2955,10 +2957,10 @@ Return Value: if (Settings->UserControlOfIdleSettings == IdleAllowUserControl) { - status = UpdateWmiInstanceForS0Idle(AddInstance); - if (!NT_SUCCESS(status)) { - return status; - } + // status = UpdateWmiInstanceForS0Idle(AddInstance); + // if (!NT_SUCCESS(status)) { + // return status; + // } __REACTOS__ if (Settings->Enabled == WdfUseDefault) { // @@ -2989,7 +2991,7 @@ Return Value: // overridable = FALSE; - (void) UpdateWmiInstanceForS0Idle(RemoveInstance); + // (void) UpdateWmiInstanceForS0Idle(RemoveInstance); __REACTOS__ } // @@ -3017,6 +3019,7 @@ Return Value: // // IdleTimeoutType is available only on > 1.9 // +#ifndef __REACTOS__ if (Settings->Size > sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_9)) { if (firstTime) { if ((SystemManagedIdleTimeout == Settings->IdleTimeoutType) || @@ -3080,6 +3083,7 @@ Return Value: } } } +#endif if (Settings->IdleCaps == IdleCannotWakeFromS0) { // @@ -3365,11 +3369,11 @@ Return Value: if (Settings->UserControlOfWakeSettings == WakeAllowUserControl) { - status = UpdateWmiInstanceForSxWake(AddInstance); + // status = UpdateWmiInstanceForSxWake(AddInstance); __REACTOS__ - if (!NT_SUCCESS(status)) { - return status; - } + // if (!NT_SUCCESS(status)) { + // return status; + // } if (Settings->Enabled == WdfUseDefault) { // @@ -3400,7 +3404,7 @@ Return Value: // overridable = FALSE; - (void) UpdateWmiInstanceForSxWake(RemoveInstance); + // (void) UpdateWmiInstanceForSxWake(RemoveInstance); __REACTOS__ } if (firstTime) { @@ -3897,7 +3901,8 @@ FxPkgPnp::PnpDeviceUsageNotification( IsUsageSupported(_SpecialTypeToUsage(WdfSpecialFileBoot))); - if (type >= WdfSpecialFilePaging && type < WdfSpecialFileMax) { + if (type >= static_cast(WdfSpecialFilePaging) + && type < static_cast(WdfSpecialFileMax)) { if (inPath) { if (m_Device->IsFilter()) { // @@ -4210,7 +4215,7 @@ FxPkgPnp::PnpDeviceUsageNotification( if (NT_SUCCESS(status) && inPath && (HasPowerThread() == FALSE) && - type != WdfSpecialFileBoot + type != static_cast(WdfSpecialFileBoot) ) { status = QueryForPowerThread(); @@ -4537,7 +4542,7 @@ Return Value: // // Boot notification doesn't require updating device flags. // - if (Type == WdfSpecialFileBoot) { + if (Type == static_cast(WdfSpecialFileBoot)) { return oldFlags; } @@ -6239,194 +6244,196 @@ FxPkgPnp::AssignPowerFrameworkSettings( __in PWDF_POWER_FRAMEWORK_SETTINGS PowerFrameworkSettings ) { - NTSTATUS status; - PPO_FX_COMPONENT_IDLE_STATE idleStates = NULL; - ULONG idleStatesSize = 0; - PPO_FX_COMPONENT component = NULL; - ULONG componentSize = 0; - PPOX_SETTINGS poxSettings = NULL; - ULONG poxSettingsSize = 0; - BYTE * buffer = NULL; +// NTSTATUS status; +// PPO_FX_COMPONENT_IDLE_STATE idleStates = NULL; +// ULONG idleStatesSize = 0; +// PPO_FX_COMPONENT component = NULL; +// ULONG componentSize = 0; +// PPOX_SETTINGS poxSettings = NULL; +// ULONG poxSettingsSize = 0; +// BYTE * buffer = NULL; - if (FALSE==(IdleTimeoutManagement::_SystemManagedIdleTimeoutAvailable())) { - // - // If system-managed idle timeout is not available on this OS, then - // there is nothing to do. - // - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP, - "WDFDEVICE %p !devobj %p Power framework is not supported on the " - "current OS. Therefore, the power framework settings will not take " - "effect.", - m_Device->GetHandle(), - m_Device->GetDeviceObject() - ); - return STATUS_SUCCESS; - } +// if (FALSE==(IdleTimeoutManagement::_SystemManagedIdleTimeoutAvailable())) { +// // +// // If system-managed idle timeout is not available on this OS, then +// // there is nothing to do. +// // +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP, +// "WDFDEVICE %p !devobj %p Power framework is not supported on the " +// "current OS. Therefore, the power framework settings will not take " +// "effect.", +// m_Device->GetHandle(), +// m_Device->GetDeviceObject() +// ); +// return STATUS_SUCCESS; +// } - if (NULL != PowerFrameworkSettings->Component) { - // - // Caller should ensure that IdleStateCount is not zero - // - ASSERT(0 != PowerFrameworkSettings->Component->IdleStateCount); +// if (NULL != PowerFrameworkSettings->Component) { +// // +// // Caller should ensure that IdleStateCount is not zero +// // +// ASSERT(0 != PowerFrameworkSettings->Component->IdleStateCount); - // - // Compute buffer size needed for storing F-states - // - status = RtlULongMult( - PowerFrameworkSettings->Component->IdleStateCount, - sizeof(*(PowerFrameworkSettings->Component->IdleStates)), - &idleStatesSize - ); - if (FALSE == NT_SUCCESS(status)) { - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE %p !devobj %p Unable to compute length of buffer " - "required to store F-states. RtlULongMult failed with " - "%!STATUS!", - m_Device->GetHandle(), - m_Device->GetDeviceObject(), - status - ); - goto exit; - } +// // +// // Compute buffer size needed for storing F-states +// // +// status = RtlULongMult( +// PowerFrameworkSettings->Component->IdleStateCount, +// sizeof(*(PowerFrameworkSettings->Component->IdleStates)), +// &idleStatesSize +// ); +// if (FALSE == NT_SUCCESS(status)) { +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE %p !devobj %p Unable to compute length of buffer " +// "required to store F-states. RtlULongMult failed with " +// "%!STATUS!", +// m_Device->GetHandle(), +// m_Device->GetDeviceObject(), +// status +// ); +// goto exit; +// } - // - // Compute buffer size needed for storing component information - // (including F-states) - // - status = RtlULongAdd(idleStatesSize, - sizeof(*component), - &componentSize); - if (FALSE == NT_SUCCESS(status)) { - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE %p !devobj %p Unable to compute length of buffer " - "required to store driver's component information. RtlULongAdd " - "failed with %!STATUS!", - m_Device->GetHandle(), - m_Device->GetDeviceObject(), - status - ); - goto exit; - } - } +// // +// // Compute buffer size needed for storing component information +// // (including F-states) +// // +// status = RtlULongAdd(idleStatesSize, +// sizeof(*component), +// &componentSize); +// if (FALSE == NT_SUCCESS(status)) { +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE %p !devobj %p Unable to compute length of buffer " +// "required to store driver's component information. RtlULongAdd " +// "failed with %!STATUS!", +// m_Device->GetHandle(), +// m_Device->GetDeviceObject(), +// status +// ); +// goto exit; +// } +// } - // - // Compute total buffer size needed for power framework settings - // - status = RtlULongAdd(componentSize, - sizeof(*poxSettings), - &poxSettingsSize); - if (FALSE == NT_SUCCESS(status)) { - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE %p !devobj %p Unable to compute length of buffer " - "required to store driver's power framework settings. RtlULongAdd " - "failed with %!STATUS!", - m_Device->GetHandle(), - m_Device->GetDeviceObject(), - status - ); - goto exit; - } +// // +// // Compute total buffer size needed for power framework settings +// // +// status = RtlULongAdd(componentSize, +// sizeof(*poxSettings), +// &poxSettingsSize); +// if (FALSE == NT_SUCCESS(status)) { +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE %p !devobj %p Unable to compute length of buffer " +// "required to store driver's power framework settings. RtlULongAdd " +// "failed with %!STATUS!", +// m_Device->GetHandle(), +// m_Device->GetDeviceObject(), +// status +// ); +// goto exit; +// } - // - // Allocate memory to copy the settings - // - buffer = (BYTE *) MxMemory::MxAllocatePoolWithTag(NonPagedPool, - poxSettingsSize, - GetDriverGlobals()->Tag); - if (NULL == buffer) { - status = STATUS_INSUFFICIENT_RESOURCES; - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE %p !devobj %p Unable to allocate buffer required to " - "store F-states. %!STATUS!", - m_Device->GetHandle(), - m_Device->GetDeviceObject(), - status - ); - goto exit; - } +// // +// // Allocate memory to copy the settings +// // +// buffer = (BYTE *) MxMemory::MxAllocatePoolWithTag(NonPagedPool, +// poxSettingsSize, +// GetDriverGlobals()->Tag); +// if (NULL == buffer) { +// status = STATUS_INSUFFICIENT_RESOURCES; +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE %p !devobj %p Unable to allocate buffer required to " +// "store F-states. %!STATUS!", +// m_Device->GetHandle(), +// m_Device->GetDeviceObject(), +// status +// ); +// goto exit; +// } - // - // Set our pointers to point to appropriate locations in the buffer. - // - // NOTES: - // - The array of F-states comes first because it has ULONGLONG members - // because of which it has the biggest alignment requirement. - // - The logic below works even if the client driver did not specify any - // component information. In that case idleStatesSize and componentSize - // are both 0 and 'poxSettings' points to the beginning of the allocated - // buffer - // - idleStates = (PPO_FX_COMPONENT_IDLE_STATE) buffer; - component = (PPO_FX_COMPONENT) (buffer + idleStatesSize); - poxSettings = (PPOX_SETTINGS) (buffer + componentSize); +// // +// // Set our pointers to point to appropriate locations in the buffer. +// // +// // NOTES: +// // - The array of F-states comes first because it has ULONGLONG members +// // because of which it has the biggest alignment requirement. +// // - The logic below works even if the client driver did not specify any +// // component information. In that case idleStatesSize and componentSize +// // are both 0 and 'poxSettings' points to the beginning of the allocated +// // buffer +// // +// idleStates = (PPO_FX_COMPONENT_IDLE_STATE) buffer; +// component = (PPO_FX_COMPONENT) (buffer + idleStatesSize); +// poxSettings = (PPOX_SETTINGS) (buffer + componentSize); - // - // Copy the relevant parts of the settings buffer - // - poxSettings->EvtDeviceWdmPostPoFxRegisterDevice = - PowerFrameworkSettings->EvtDeviceWdmPostPoFxRegisterDevice; - poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice = - PowerFrameworkSettings->EvtDeviceWdmPrePoFxUnregisterDevice; - poxSettings->Component = PowerFrameworkSettings->Component; - poxSettings->ComponentActiveConditionCallback = - PowerFrameworkSettings->ComponentActiveConditionCallback; - poxSettings->ComponentIdleConditionCallback = - PowerFrameworkSettings->ComponentIdleConditionCallback; - poxSettings->ComponentIdleStateCallback = - PowerFrameworkSettings->ComponentIdleStateCallback; - poxSettings->PowerControlCallback = - PowerFrameworkSettings->PowerControlCallback; - poxSettings->PoFxDeviceContext = PowerFrameworkSettings->PoFxDeviceContext; +// // +// // Copy the relevant parts of the settings buffer +// // +// poxSettings->EvtDeviceWdmPostPoFxRegisterDevice = +// PowerFrameworkSettings->EvtDeviceWdmPostPoFxRegisterDevice; +// poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice = +// PowerFrameworkSettings->EvtDeviceWdmPrePoFxUnregisterDevice; +// poxSettings->Component = PowerFrameworkSettings->Component; +// poxSettings->ComponentActiveConditionCallback = +// PowerFrameworkSettings->ComponentActiveConditionCallback; +// poxSettings->ComponentIdleConditionCallback = +// PowerFrameworkSettings->ComponentIdleConditionCallback; +// poxSettings->ComponentIdleStateCallback = +// PowerFrameworkSettings->ComponentIdleStateCallback; +// poxSettings->PowerControlCallback = +// PowerFrameworkSettings->PowerControlCallback; +// poxSettings->PoFxDeviceContext = PowerFrameworkSettings->PoFxDeviceContext; - if (NULL != PowerFrameworkSettings->Component) { - // - // Copy the component information - // - poxSettings->Component = component; - RtlCopyMemory(poxSettings->Component, - PowerFrameworkSettings->Component, - sizeof(*component)); +// if (NULL != PowerFrameworkSettings->Component) { +// // +// // Copy the component information +// // +// poxSettings->Component = component; +// RtlCopyMemory(poxSettings->Component, +// PowerFrameworkSettings->Component, +// sizeof(*component)); - // - // Caller should ensure that IdleStates is not NULL - // - ASSERT(NULL != PowerFrameworkSettings->Component->IdleStates); +// // +// // Caller should ensure that IdleStates is not NULL +// // +// ASSERT(NULL != PowerFrameworkSettings->Component->IdleStates); - // - // Copy the F-states - // - poxSettings->Component->IdleStates = idleStates; - RtlCopyMemory(poxSettings->Component->IdleStates, - PowerFrameworkSettings->Component->IdleStates, - idleStatesSize); - } +// // +// // Copy the F-states +// // +// poxSettings->Component->IdleStates = idleStates; +// RtlCopyMemory(poxSettings->Component->IdleStates, +// PowerFrameworkSettings->Component->IdleStates, +// idleStatesSize); +// } - // - // Commit these settings - // - status = m_PowerPolicyMachine.m_Owner-> - m_IdleSettings.m_TimeoutMgmt.CommitPowerFrameworkSettings( - GetDriverGlobals(), - poxSettings - ); - if (FALSE == NT_SUCCESS(status)) { - goto exit; - } +// // +// // Commit these settings +// // +// status = m_PowerPolicyMachine.m_Owner-> +// m_IdleSettings.m_TimeoutMgmt.CommitPowerFrameworkSettings( +// GetDriverGlobals(), +// poxSettings +// ); +// if (FALSE == NT_SUCCESS(status)) { +// goto exit; +// } - status = STATUS_SUCCESS; +// status = STATUS_SUCCESS; -exit: - if (FALSE == NT_SUCCESS(status)) { - if (NULL != buffer) { - MxMemory::MxFreePool(buffer); - } - } - return status; +// exit: +// if (FALSE == NT_SUCCESS(status)) { +// if (NULL != buffer) { +// MxMemory::MxFreePool(buffer); +// } +// } +// return status; + ROSWDFNOTIMPLEMENTED; + return STATUS_SUCCESS; } DEVICE_POWER_STATE diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/interruptobject.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/interruptobject.cpp index 2929008a7a3..868d2cd62ed 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/interruptobject.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/interruptobject.cpp @@ -521,7 +521,7 @@ FxInterrupt::Initialize( // reference, so that even if we return error, the reference is // still there to be removed on cleanup. // - ADDREF(_InterruptThunk); + ADDREF((PVOID)_InterruptThunk); // // Values always supplied by the caller @@ -881,7 +881,7 @@ FxInterrupt::DeleteObject( // // Use the base FxObject's DeleteObject implementation which will Dispose us // - __super::DeleteObject(); + FxNonPagedObject::DeleteObject(); // __super call } // @@ -1678,7 +1678,7 @@ FxInterrupt::FlushAndRundown() // // Release the reference taken in FxInterrupt::Initialize // - RELEASE(_InterruptThunk); + RELEASE((PVOID)_InterruptThunk); } // diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/eventqueuekm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/eventqueuekm.cpp index 76f262ba957..5b6ec6b885a 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/eventqueuekm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/eventqueuekm.cpp @@ -70,7 +70,7 @@ FxWorkItemEventQueue::QueueWorkItem( // object), taking this ref prevents the globals from going away until a // corresponding deref at the end of workitem. // - m_PkgPnp->GetDriverGlobals()->ADDREF(_WorkItemCallback); + m_PkgPnp->GetDriverGlobals()->ADDREF((PVOID)_WorkItemCallback); m_WorkItem.Enqueue( (PMX_WORKITEM_ROUTINE) _WorkItemCallback, @@ -112,7 +112,7 @@ Routine Description: // // Release the ref on FxDriverGlobals taken before queuing this workitem. // - pFxDriverGlobals->RELEASE(_WorkItemCallback); + pFxDriverGlobals->RELEASE((PVOID)_WorkItemCallback); Mx::MxDereferenceObject(pDriverObject); } diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgfdokm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgfdokm.cpp index 5b65240a539..ce5bf736a4b 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgfdokm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgfdokm.cpp @@ -25,7 +25,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include #include @@ -456,108 +456,110 @@ FxPkgFdo::QueryForDsfInterface( VOID ) { - WDF_DSF_INTERFACE dsfInterface; - NTSTATUS status; - BOOLEAN derefQI = FALSE; +// __REACTOS__ : not supported +// WDF_DSF_INTERFACE dsfInterface; +// NTSTATUS status; +// BOOLEAN derefQI = FALSE; - RtlZeroMemory(&dsfInterface, sizeof(dsfInterface)); +// RtlZeroMemory(&dsfInterface, sizeof(dsfInterface)); - // - // Since there are some stacks that are not PnP re-entrant (like USBHUB, - // xpsp2), we specify that the QI goes only to our attached device and - // not to the top of the stack as a normal QI irp would. - // - // We also do this a preventative measure for other stacks we don't know - // about internally and do not have access to when testing. - // - status = m_Device->QueryForInterface(&GUID_WDF_DSF_INTERFACE, - (PINTERFACE) &dsfInterface, - sizeof(dsfInterface), - WDM_DSF_INTERFACE_V1_0, - NULL, - m_Device->GetAttachedDevice() - ); +// // +// // Since there are some stacks that are not PnP re-entrant (like USBHUB, +// // xpsp2), we specify that the QI goes only to our attached device and +// // not to the top of the stack as a normal QI irp would. +// // +// // We also do this a preventative measure for other stacks we don't know +// // about internally and do not have access to when testing. +// // +// status = m_Device->QueryForInterface(&GUID_WDF_DSF_INTERFACE, +// (PINTERFACE) &dsfInterface, +// sizeof(dsfInterface), +// WDM_DSF_INTERFACE_V1_0, +// NULL, +// m_Device->GetAttachedDevice() +// ); - if (status == STATUS_NOT_SUPPORTED) { - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP, - "Lower stack does not have a DSF interface"); - status = STATUS_SUCCESS; - goto Done; - } +// if (status == STATUS_NOT_SUPPORTED) { +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP, +// "Lower stack does not have a DSF interface"); +// status = STATUS_SUCCESS; +// goto Done; +// } - if (!NT_SUCCESS(status)) { - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, - "Lower stack returned an error for query DSF interface, %!STATUS!", - status); - goto Done; - } +// if (!NT_SUCCESS(status)) { +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, +// "Lower stack returned an error for query DSF interface, %!STATUS!", +// status); +// goto Done; +// } - derefQI = TRUE; +// derefQI = TRUE; - // - // Basic run time checks. - // - if (dsfInterface.Interface.Version != WDM_DSF_INTERFACE_V1_0) { - status = STATUS_REVISION_MISMATCH; - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, - "Lower DSF stack supports v(%x), requested v(%x), %!STATUS!", - dsfInterface.Interface.Version, - WDM_DSF_INTERFACE_V1_0, - status); - goto Done; - } +// // +// // Basic run time checks. +// // +// if (dsfInterface.Interface.Version != WDM_DSF_INTERFACE_V1_0) { +// status = STATUS_REVISION_MISMATCH; +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, +// "Lower DSF stack supports v(%x), requested v(%x), %!STATUS!", +// dsfInterface.Interface.Version, +// WDM_DSF_INTERFACE_V1_0, +// status); +// goto Done; +// } - // - // Ex functions should be both set or cleared. - // Active/Inactive functions should be both set or cleared. - // Ex function must be present. - // Note: !!(ptr) expression below converts ptr value to true/false value. - // I.e., ptr==NULL to false and ptr!=NULL to true. - // - if (!((!!(dsfInterface.IoConnectInterruptEx) == - !!(dsfInterface.IoDisconnectInterruptEx)) && - (!!(dsfInterface.IoReportInterruptActive) == - !!(dsfInterface.IoReportInterruptInactive)) && - (dsfInterface.IoConnectInterruptEx != NULL) - )) { - status = STATUS_DATA_ERROR; - DoTraceLevelMessage( - GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, - "Function mismatch detected in DSF interface, %!STATUS!", - status); - goto Done; - } +// // +// // Ex functions should be both set or cleared. +// // Active/Inactive functions should be both set or cleared. +// // Ex function must be present. +// // Note: !!(ptr) expression below converts ptr value to true/false value. +// // I.e., ptr==NULL to false and ptr!=NULL to true. +// // +// if (!((!!(dsfInterface.IoConnectInterruptEx) == +// !!(dsfInterface.IoDisconnectInterruptEx)) && +// (!!(dsfInterface.IoReportInterruptActive) == +// !!(dsfInterface.IoReportInterruptInactive)) && +// (dsfInterface.IoConnectInterruptEx != NULL) +// )) { +// status = STATUS_DATA_ERROR; +// DoTraceLevelMessage( +// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP, +// "Function mismatch detected in DSF interface, %!STATUS!", +// status); +// goto Done; +// } - // - // Info is correct. - // - m_IoConnectInterruptEx = dsfInterface.IoConnectInterruptEx; - m_IoDisconnectInterruptEx = dsfInterface.IoDisconnectInterruptEx; +// // +// // Info is correct. +// // +// m_IoConnectInterruptEx = dsfInterface.IoConnectInterruptEx; +// m_IoDisconnectInterruptEx = dsfInterface.IoDisconnectInterruptEx; - // - // If DSF interface provides active/inactive functions then use them - // - if (dsfInterface.IoReportInterruptActive != NULL) - { - m_IoReportInterruptActive = dsfInterface.IoReportInterruptActive; - m_IoReportInterruptInactive = dsfInterface.IoReportInterruptInactive; - } +// // +// // If DSF interface provides active/inactive functions then use them +// // +// if (dsfInterface.IoReportInterruptActive != NULL) +// { +// m_IoReportInterruptActive = dsfInterface.IoReportInterruptActive; +// m_IoReportInterruptInactive = dsfInterface.IoReportInterruptInactive; +// } -Done: +// Done: - // - // The contract with the DSF layer is to release the interface right away; - // the embedded interrupt function ptrs will be valid until this driver is - // unloaded. - // - if (derefQI) { - dsfInterface.Interface.InterfaceDereference(dsfInterface.Interface.Context); - } +// // +// // The contract with the DSF layer is to release the interface right away; +// // the embedded interrupt function ptrs will be valid until this driver is +// // unloaded. +// // +// if (derefQI) { +// dsfInterface.Interface.InterfaceDereference(dsfInterface.Interface.Context); +// } - return status; +// return status; + return STATUS_NOT_IMPLEMENTED; } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpdokm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpdokm.cpp index 8d21d10e4b8..59c3e736705 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpdokm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpdokm.cpp @@ -24,7 +24,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include // Tracing support diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpnpkm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpnpkm.cpp index 31f8086dcc5..71de6c60984 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpnpkm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpnpkm.cpp @@ -1,7 +1,7 @@ // // Copyright (C) Microsoft. All rights reserved. // -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include #include @@ -307,70 +307,70 @@ FxPkgPnp::WriteStateToRegistry( ZwSetValueKey(RegKey, ValueName, 0, REG_DWORD, &Value, sizeof(Value)); } -NTSTATUS -FxPkgPnp::UpdateWmiInstanceForS0Idle( - __in FxWmiInstanceAction Action - ) -{ - FxWmiProvider* pProvider; - NTSTATUS status; +// NTSTATUS __REACTOS__ +// FxPkgPnp::UpdateWmiInstanceForS0Idle( +// __in FxWmiInstanceAction Action +// ) +// { +// FxWmiProvider* pProvider; +// NTSTATUS status; - switch(Action) { - case AddInstance: - if (m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance == NULL) { - FxWmiInstanceInternalCallbacks cb; +// switch(Action) { +// case AddInstance: +// if (m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance == NULL) { +// FxWmiInstanceInternalCallbacks cb; - cb.SetInstance = _S0IdleSetInstance; - cb.QueryInstance = _S0IdleQueryInstance; - cb.SetItem = _S0IdleSetItem; +// cb.SetInstance = _S0IdleSetInstance; +// cb.QueryInstance = _S0IdleQueryInstance; +// cb.SetItem = _S0IdleSetItem; - status = RegisterPowerPolicyWmiInstance( - &GUID_POWER_DEVICE_ENABLE, - &cb, - &m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance); +// status = RegisterPowerPolicyWmiInstance( +// &GUID_POWER_DEVICE_ENABLE, +// &cb, +// &m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance); - if (!NT_SUCCESS(status)) { - return status; - } - } - else { - pProvider = m_PowerPolicyMachine.m_Owner->m_IdleSettings. - WmiInstance->GetProvider(); +// if (!NT_SUCCESS(status)) { +// return status; +// } +// } +// else { +// pProvider = m_PowerPolicyMachine.m_Owner->m_IdleSettings. +// WmiInstance->GetProvider(); - // - // Enable the WMI GUID by adding the instance back to the provider's - // list. If there is an error, ignore it. It just means we were - // racing with another thread removing or adding the instance. - // - (void) pProvider->AddInstance( - m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance, - TRUE - ); - } - break; +// // +// // Enable the WMI GUID by adding the instance back to the provider's +// // list. If there is an error, ignore it. It just means we were +// // racing with another thread removing or adding the instance. +// // +// (void) pProvider->AddInstance( +// m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance, +// TRUE +// ); +// } +// break; - case RemoveInstance: - if (m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance != NULL) { - // - // Disable the WMI guid by removing it from the provider's list of - // instances. - // - pProvider = m_PowerPolicyMachine.m_Owner->m_IdleSettings. - WmiInstance->GetProvider(); +// case RemoveInstance: +// if (m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance != NULL) { +// // +// // Disable the WMI guid by removing it from the provider's list of +// // instances. +// // +// pProvider = m_PowerPolicyMachine.m_Owner->m_IdleSettings. +// WmiInstance->GetProvider(); - pProvider->RemoveInstance( - m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance - ); - } - break; +// pProvider->RemoveInstance( +// m_PowerPolicyMachine.m_Owner->m_IdleSettings.WmiInstance +// ); +// } +// break; - default: - ASSERT(FALSE); - break; - } +// default: +// ASSERT(FALSE); +// break; +// } - return STATUS_SUCCESS;; -} +// return STATUS_SUCCESS;; +// } VOID FxPkgPnp::ReadRegistryS0Idle( @@ -401,69 +401,69 @@ FxPkgPnp::ReadRegistryS0Idle( } } -NTSTATUS -FxPkgPnp::UpdateWmiInstanceForSxWake( - __in FxWmiInstanceAction Action - ) -{ - FxWmiProvider* pProvider; - NTSTATUS status; +// NTSTATUS __REACTOS__ +// FxPkgPnp::UpdateWmiInstanceForSxWake( +// __in FxWmiInstanceAction Action +// ) +// { +// FxWmiProvider* pProvider; +// NTSTATUS status; - switch(Action) { - case AddInstance: - if (m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance == NULL) { - FxWmiInstanceInternalCallbacks cb; +// switch(Action) { +// case AddInstance: +// if (m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance == NULL) { +// FxWmiInstanceInternalCallbacks cb; - cb.SetInstance = _SxWakeSetInstance; - cb.QueryInstance = _SxWakeQueryInstance; - cb.SetItem = _SxWakeSetItem; +// cb.SetInstance = _SxWakeSetInstance; +// cb.QueryInstance = _SxWakeQueryInstance; +// cb.SetItem = _SxWakeSetItem; - status = RegisterPowerPolicyWmiInstance( - &GUID_POWER_DEVICE_WAKE_ENABLE, - &cb, - &m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance); +// status = RegisterPowerPolicyWmiInstance( +// &GUID_POWER_DEVICE_WAKE_ENABLE, +// &cb, +// &m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance); - if (!NT_SUCCESS(status)) { - return status; - } - } else { - pProvider = m_PowerPolicyMachine.m_Owner->m_WakeSettings. - WmiInstance->GetProvider(); +// if (!NT_SUCCESS(status)) { +// return status; +// } +// } else { +// pProvider = m_PowerPolicyMachine.m_Owner->m_WakeSettings. +// WmiInstance->GetProvider(); - // - // Enable the WMI GUID by adding the instance back to the provider's - // list. If there is an error, ignore it. It just means we were - // racing with another thread removing or adding the instance. - // - (void) pProvider->AddInstance( - m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance, - TRUE - ); - } - break; +// // +// // Enable the WMI GUID by adding the instance back to the provider's +// // list. If there is an error, ignore it. It just means we were +// // racing with another thread removing or adding the instance. +// // +// (void) pProvider->AddInstance( +// m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance, +// TRUE +// ); +// } +// break; - case RemoveInstance: - if (m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance != NULL) { - // - // Disable the WMI guid by removing it from the provider's list of - // instances. - // - pProvider = m_PowerPolicyMachine.m_Owner->m_WakeSettings. - WmiInstance->GetProvider(); +// case RemoveInstance: +// if (m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance != NULL) { +// // +// // Disable the WMI guid by removing it from the provider's list of +// // instances. +// // +// pProvider = m_PowerPolicyMachine.m_Owner->m_WakeSettings. +// WmiInstance->GetProvider(); - pProvider->RemoveInstance( - m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance - ); - } - break; +// pProvider->RemoveInstance( +// m_PowerPolicyMachine.m_Owner->m_WakeSettings.WmiInstance +// ); +// } +// break; - default: - ASSERT(FALSE); - break; - } +// default: +// ASSERT(FALSE); +// break; +// } - return STATUS_SUCCESS; -} +// return STATUS_SUCCESS; +// } VOID FxPkgPnp::ReadRegistrySxWake( @@ -530,7 +530,8 @@ FxPkgPnp::RevokeDmaEnablerResources( __in FxDmaEnabler *DmaEnabler ) { - DmaEnabler->RevokeResources(); + // DmaEnabler->RevokeResources(); + ROSWDFNOTIMPLEMENTED; } VOID diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/interruptobjectkm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/interruptobjectkm.cpp index f93fc0de701..a083731ada9 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/interruptobjectkm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/interruptobjectkm.cpp @@ -31,7 +31,7 @@ Revision History: #include "pnppriv.hpp" // Tracing support -#include "InterruptObjectKm.tmh" +// #include "InterruptObjectKm.tmh" _Must_inspect_result_ NTSTATUS diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpprivkm.hpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpprivkm.hpp index a545b6f0057..0927a91c48d 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpprivkm.hpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpprivkm.hpp @@ -5,11 +5,11 @@ #define _PNPPRIVKM_H_ // public headers -#include "WdfDmaEnabler.h" +#include "wdfdmaenabler.h" // private headers -#include "FxIrpQueue.hpp" -#include "FxCallback.hpp" +#include "fxirpqueue.hpp" +#include "fxcallback.hpp" // __drv_functionClass(EVT_SYSTEMWORKITEM) @@ -26,25 +26,41 @@ typedef EVT_SYSTEMWORKITEM *PFN_WDF_SYSTEMWORKITEM; // -#include "FxCallbackSpinlock.hpp" -#include "FxCallbackMutexLock.hpp" -#include "FxPackage.hpp" -#include "IfxMemory.hpp" -#include "FxCallback.hpp" -#include "FxRequestContext.hpp" -#include "FxRequestContextTypes.h" -#include "FxRequestBase.hpp" -#include "FxRequest.hpp" -#include "FxPkgPnp.hpp" -#include "FxPkgIo.hpp" -#include "FxIoQueue.hpp" +#include "fxcallbackspinlock.hpp" +#include "fxcallbackmutexlock.hpp" +#include "fxpackage.hpp" +#include "ifxmemory.hpp" +#include "fxcallback.hpp" +#include "fxrequestcontext.hpp" +#include "fxrequestcontexttypes.h" +#include "fxrequestbase.hpp" +#include "fxrequest.hpp" +#include "fxpkgpnp.hpp" +#include "fxpkgio.hpp" +#include "fxioqueue.hpp" -#include "FxDmaEnabler.hpp" -#include "FxSystemWorkItem.hpp" +#include "fxdmaenabler.hpp" +#include "fxsystemworkitem.hpp" + +// #include "FxDsf.h" // DSF support. +// #include +// #include "FxTelemetry.hpp" +// __REACTOS__ +typedef struct _STACK_DEVICE_CAPABILITIES { + // + // The capabilities as garnered from IRP_MN_QUERY_CAPABILITIES. + // + DEVICE_CAPABILITIES DeviceCaps; + + // + // The lowest-power D-state that a device can be in and still generate + // a wake signal, indexed by system state. (PowerSystemUnspecified is + // an unused slot in this array.) + // + DEVICE_WAKE_DEPTH DeepestWakeableDstate[PowerSystemHibernate+1]; +} STACK_DEVICE_CAPABILITIES, *PSTACK_DEVICE_CAPABILITIES; +// end __REACTOS__ -#include "FxDsf.h" // DSF support. -#include -#include "FxTelemetry.hpp" _Must_inspect_result_ NTSTATUS diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpstatemachinekm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpstatemachinekm.cpp index 4bab9c8f620..5c84c95a541 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpstatemachinekm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpstatemachinekm.cpp @@ -24,7 +24,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include #include diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerpolicystatemachinekm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerpolicystatemachinekm.cpp index a1aa32c43e4..14c0c33c933 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerpolicystatemachinekm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerpolicystatemachinekm.cpp @@ -17,13 +17,13 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #if FX_IS_KERNEL_MODE #include #endif -#include "FxUsbIdleInfo.hpp" +#include "fxusbidleinfo.hpp" extern "C" { #if defined(EVENT_TRACING) @@ -163,33 +163,34 @@ FxPkgPnp::PowerPolicySubmitUsbIdleNotification( VOID ) { - FxIrp* usbIdleIrp; + // FxIrp* usbIdleIrp; - // - // This will be set to TRUE if USBSS completion event gets dropped. - // - m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_EventDropped = FALSE; + // // + // // This will be set to TRUE if USBSS completion event gets dropped. + // // + // m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_EventDropped = FALSE; - usbIdleIrp = &m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_IdleIrp; + // usbIdleIrp = &m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_IdleIrp; - usbIdleIrp->Reuse(); + // usbIdleIrp->Reuse(); - usbIdleIrp->SetCompletionRoutineEx( - m_Device->GetDeviceObject(), - _PowerPolicyUsbSelectiveSuspendCompletionRoutine, - this); + // usbIdleIrp->SetCompletionRoutineEx( + // m_Device->GetDeviceObject(), + // _PowerPolicyUsbSelectiveSuspendCompletionRoutine, + // this); - usbIdleIrp->SetMajorFunction(IRP_MJ_INTERNAL_DEVICE_CONTROL); - usbIdleIrp->SetParameterIoctlCode( - IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION); - usbIdleIrp->SetParameterIoctlInputBufferLength( - sizeof(m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_CallbackInfo)); - usbIdleIrp->SetParameterIoctlType3InputBuffer( - (PVOID) &m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_CallbackInfo); + // usbIdleIrp->SetMajorFunction(IRP_MJ_INTERNAL_DEVICE_CONTROL); + // usbIdleIrp->SetParameterIoctlCode( + // IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION); + // usbIdleIrp->SetParameterIoctlInputBufferLength( + // sizeof(m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_CallbackInfo)); + // usbIdleIrp->SetParameterIoctlType3InputBuffer( + // (PVOID) &m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_CallbackInfo); - m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_IdleIrp.CallDriver( - m_Device->GetAttachedDevice() - ); + // m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_IdleIrp.CallDriver( + // m_Device->GetAttachedDevice() + // ); + ROSWDFNOTIMPLEMENTED; } VOID diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerstatemachinekm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerstatemachinekm.cpp index 9c340c367e6..5dc4cfa968c 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerstatemachinekm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerstatemachinekm.cpp @@ -23,7 +23,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" extern "C" { #if defined(EVENT_TRACING) @@ -51,8 +51,8 @@ Return Value: --*/ { - FxTransactionedEntry* ple; - NTSTATUS status; + // FxTransactionedEntry* ple; + // NTSTATUS status; BOOLEAN result; result = TRUE; @@ -60,21 +60,21 @@ Return Value: // // Power up each dma enabler // - if (m_DmaEnablerList != NULL) { - m_DmaEnablerList->LockForEnum(GetDriverGlobals()); + // if (m_DmaEnablerList != NULL) { + // m_DmaEnablerList->LockForEnum(GetDriverGlobals()); - ple = NULL; - while ((ple = m_DmaEnablerList->GetNextEntry(ple)) != NULL) { - status = ((FxDmaEnabler*) ple->GetTransactionedObject())->PowerUp(); + // ple = NULL; + // while ((ple = m_DmaEnablerList->GetNextEntry(ple)) != NULL) { + // status = ((FxDmaEnabler*) ple->GetTransactionedObject())->PowerUp(); - if (!NT_SUCCESS(status)) { - result = FALSE; - break; - } - } + // if (!NT_SUCCESS(status)) { + // result = FALSE; + // break; + // } + // } - m_DmaEnablerList->UnlockFromEnum(GetDriverGlobals()); - } + // m_DmaEnablerList->UnlockFromEnum(GetDriverGlobals()); + // } return result; } @@ -97,8 +97,8 @@ Return Value: --*/ { - FxTransactionedEntry* ple; - NTSTATUS status; + // FxTransactionedEntry* ple; + // NTSTATUS status; BOOLEAN result; result = TRUE; @@ -106,25 +106,25 @@ Return Value: // // Power up each dma enabler // - if (m_DmaEnablerList != NULL) { - m_DmaEnablerList->LockForEnum(GetDriverGlobals()); + // if (m_DmaEnablerList != NULL) { + // m_DmaEnablerList->LockForEnum(GetDriverGlobals()); - ple = NULL; - while ((ple = m_DmaEnablerList->GetNextEntry(ple)) != NULL) { - status = ((FxDmaEnabler*) ple->GetTransactionedObject())->PowerDown(); + // ple = NULL; + // while ((ple = m_DmaEnablerList->GetNextEntry(ple)) != NULL) { + // status = ((FxDmaEnabler*) ple->GetTransactionedObject())->PowerDown(); - if (!NT_SUCCESS(status)) { - // - // We do not break out of the loop on power down failure. We will - // continue to power down each channel regardless of the previous - // channel's power down status. - // - result = FALSE; - } - } + // if (!NT_SUCCESS(status)) { + // // + // // We do not break out of the loop on power down failure. We will + // // continue to power down each channel regardless of the previous + // // channel's power down status. + // // + // result = FALSE; + // } + // } - m_DmaEnablerList->UnlockFromEnum(GetDriverGlobals()); - } + // m_DmaEnablerList->UnlockFromEnum(GetDriverGlobals()); + // } return result; } diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/supportkm.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/supportkm.cpp index 797237299e3..34e7074f70c 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/supportkm.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/supportkm.cpp @@ -21,7 +21,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include #if defined(EVENT_TRACING) @@ -200,7 +200,11 @@ Return value: Pointer to the object that can be passed in to IoAllocateWorkItem --*/ { - return (PVOID) FxLibraryGlobals.DriverObject; + // return (PVOID) FxLibraryGlobals.DriverObject; + // __REACTOS__ : we don't have a WDF driver object here, use a child one + + PFX_DRIVER_GLOBALS fxDriverGlobals = GetFxDriverGlobals(WdfDriverGlobals); + return fxDriverGlobals->Driver->GetDriverObject(); } BOOLEAN @@ -291,6 +295,7 @@ SendDeviceUsageNotificationWorker( } VOID +STDCALL _DeviceUsageNotificationWorkItem( __in MdDeviceObject DeviceObject, __in PVOID Context diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pdopower.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pdopower.cpp index a95d1635928..c2f3be769c7 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pdopower.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pdopower.cpp @@ -96,12 +96,9 @@ FxPkgPdo::DispatchSystemSetPower( __in FxIrp *Irp ) { - NTSTATUS status; KIRQL irql; MxDeviceObject deviceObject(m_Device->GetDeviceObject()); - status = STATUS_SUCCESS; - m_SystemPowerState = (BYTE) Irp->GetParameterPowerStateSystemState(); deviceObject.SetPowerState(SystemPowerState, Irp->GetParameterPowerState()); @@ -155,10 +152,6 @@ FxPkgPdo::DispatchDeviceSetPower( __in FxIrp *Irp ) { - NTSTATUS status; - - status = STATUS_SUCCESS; - if (IsPowerPolicyOwner()) { if (m_PowerPolicyMachine.m_Owner->m_RequestedPowerUpIrp == FALSE && m_PowerPolicyMachine.m_Owner->m_RequestedPowerDownIrp == FALSE) { diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnppriv.hpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnppriv.hpp index 66dcfffd86f..4e6088a491a 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnppriv.hpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnppriv.hpp @@ -38,18 +38,18 @@ Revision History: // // common header file for all irphandler\* files // -#include "irphandlerspriv.hpp" +#include "shared/irphandlers/irphandlerspriv.hpp" // // public headers // -#include "wdfDevice.h" -#include "wdfChildList.h" -#include "wdfPdo.h" +#include "wdfdevice.h" +#include "wdfchildlist.h" +#include "wdfpdo.h" #include "wdffdo.h" -#include "wdfQueryInterface.h" -#include "wdfMemory.h" -#include "wdfWmi.h" +#include "wdfqueryinterface.h" +#include "wdfmemory.h" +#include "wdfwmi.h" @@ -70,7 +70,7 @@ Revision History: #ifndef _INTERRUPT_COMMON_H_ -#include "WdfInterrupt.h" +#include "wdfinterrupt.h" #endif #ifndef _WUDFDDI_TYPES_PRIVATE_H_ #include "wdfrequest.h" @@ -80,70 +80,70 @@ Revision History: // // private headers // -#include "FxWaitLock.hpp" -#include "FxTransactionedList.hpp" -#include "FxRelatedDeviceList.hpp" -#include "FxCollection.hpp" +#include "fxwaitlock.hpp" +#include "fxtransactionedlist.hpp" +#include "fxrelateddevicelist.hpp" +#include "fxcollection.hpp" // support -#include "StringUtil.hpp" -#include "FxString.hpp" -#include "FxDeviceText.hpp" -#include "FxCallback.hpp" -#include "FxSystemThread.hpp" -#include "FxResource.hpp" +#include "stringutil.hpp" +#include "fxstring.hpp" +#include "fxdevicetext.hpp" +#include "fxcallback.hpp" +#include "fxsystemthread.hpp" +#include "fxresource.hpp" // io -#include "FxPkgIoShared.hpp" +#include "fxpkgioshared.hpp" // // FxDeviceInitShared.hpp is new header with definition of PdoInit split from // FxDeviceInit.hpp // -#include "FxDeviceInitShared.hpp" +#include "fxdeviceinitshared.hpp" // bus -#include "FxChildList.hpp" +#include "fxchildlist.hpp" // FxDevice To Shared interface header -#include "FxDeviceToMxInterface.hpp" +#include "fxdevicetomxinterface.hpp" // mode specific headers #if FX_IS_KERNEL_MODE -#include "PnpPrivKM.hpp" +#include "pnpprivkm.hpp" #elif FX_IS_USER_MODE -#include "PnpPrivUM.hpp" +#include "pnpprivum.hpp" #endif -#include "FxSpinLock.hpp" +#include "fxspinlock.hpp" #if FX_IS_KERNEL_MODE -#include "FxInterruptKm.hpp" +#include "fxinterruptkm.hpp" #elif FX_IS_USER_MODE -#include "FxInterruptUm.hpp" +#include "fxinterruptum.hpp" #endif #if FX_IS_KERNEL_MODE -#include "FxPerfTraceKm.hpp" +#include "fxperftracekm.hpp" #endif -#include "FxTelemetry.hpp" +#include "fxtelemetry.hpp" // pnp -#include "FxRelatedDevice.hpp" -#include "FxDeviceInterface.hpp" -#include "FxQueryInterface.hpp" -#include "FxPnpCallbacks.hpp" -#include "FxPackage.hpp" -#include "FxPkgPnp.hpp" -#include "FxWatchDog.hpp" -#include "FxPkgPdo.hpp" -#include "FxPkgFdo.hpp" +#include "fxrelateddevice.hpp" +#include "fxdeviceinterface.hpp" +#include "fxqueryinterface.hpp" +#include "fxpnpcallbacks.hpp" +#include "fxpackage.hpp" +#include "fxpkgpnp.hpp" +#include "fxwatchdog.hpp" +#include "fxpkgpdo.hpp" +#include "fxpkgfdo.hpp" // wmi -#include "FxWmiIrpHandler.hpp" -#include "FxWmiProvider.hpp" -#include "FxWmiInstance.hpp" +#include "fxwmiirphandler.hpp" +#include "fxwmiprovider.hpp" +#include "fxwmiinstance.hpp" VOID diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnpstatemachine.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnpstatemachine.cpp index 4e7b8dd971b..c3e4b26ea58 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnpstatemachine.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnpstatemachine.cpp @@ -3270,7 +3270,7 @@ Return Value: // // Reset WMI state // - This->m_Device->m_PkgWmi->ResetStateForPdoRestart(); + // This->m_Device->m_PkgWmi->ResetStateForPdoRestart(); __REACTOS__ This->m_Device->m_PkgIo->ResetStateForRestart(); @@ -3354,7 +3354,7 @@ Return Value: if (This->m_DeviceRemoveProcessed == NULL) { status = Mx::MxAcquireRemoveLock( This->m_Device->GetRemoveLock(), - &FxPkgPnp::PnpEventFinal); + (PVOID)&FxPkgPnp::PnpEventFinal); ASSERT(NT_SUCCESS(status)); UNREFERENCED_PARAMETER(status); @@ -3389,7 +3389,7 @@ Return Value: // Mx::MxReleaseRemoveLockAndWait( This->m_Device->GetRemoveLock(), - &FxPkgPnp::PnpEventFinal); + (PVOID)&FxPkgPnp::PnpEventFinal); // // Delete the object when we exit the state machine. Dispose was run diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerpolicystatemachine.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerpolicystatemachine.cpp index b61ae054062..e6ed0ddbae2 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerpolicystatemachine.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerpolicystatemachine.cpp @@ -32,7 +32,7 @@ Revision History: #include #endif -#include "FxUsbIdleInfo.hpp" +#include "fxusbidleinfo.hpp" extern "C" { #if defined(EVENT_TRACING) diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerstatemachine.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerstatemachine.cpp index 6474f5ba4b5..703c20a1be8 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerstatemachine.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerstatemachine.cpp @@ -2283,7 +2283,7 @@ Return Value: status = This->m_SelfManagedIoMachine->Start(); if (!NT_SUCCESS(status)) { - return WdfDevStatePowerInitialSelfManagedIoFailed; + // return WdfDevStatePowerInitialSelfManagedIoFailed; __REACTOS__ : allow to fail } } diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/poxinterface.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/poxinterface.cpp index 0b2ce3deea6..e2737fdc585 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/poxinterface.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/poxinterface.cpp @@ -45,66 +45,68 @@ FxPoxInterface::CreateDevicePowerRequirementMachine( VOID ) { - NTSTATUS status; - FxDevicePwrRequirementMachine * fxDprMachine = NULL; +// NTSTATUS status; +// FxDevicePwrRequirementMachine * fxDprMachine = NULL; - ASSERT(NULL == m_DevicePowerRequirementMachine); +// ASSERT(NULL == m_DevicePowerRequirementMachine); - fxDprMachine = new (m_PkgPnp->GetDriverGlobals()) - FxDevicePwrRequirementMachine(this); - if (NULL == fxDprMachine) { - status = STATUS_INSUFFICIENT_RESOURCES; - DoTraceLevelMessage( - m_PkgPnp->GetDriverGlobals(), - TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE 0x%p !devobj 0x%p failed to allocate " - "FxDevicePwrRequirementMachine. %!STATUS!.", - m_PkgPnp->GetDevice()->GetHandle(), - m_PkgPnp->GetDevice()->GetDeviceObject(), - status); - goto exit; - } +// fxDprMachine = new (m_PkgPnp->GetDriverGlobals()) +// FxDevicePwrRequirementMachine(this); +// if (NULL == fxDprMachine) { +// status = STATUS_INSUFFICIENT_RESOURCES; +// DoTraceLevelMessage( +// m_PkgPnp->GetDriverGlobals(), +// TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE 0x%p !devobj 0x%p failed to allocate " +// "FxDevicePwrRequirementMachine. %!STATUS!.", +// m_PkgPnp->GetDevice()->GetHandle(), +// m_PkgPnp->GetDevice()->GetDeviceObject(), +// status); +// goto exit; +// } - status = fxDprMachine->Initialize(m_PkgPnp->GetDriverGlobals()); - if (FALSE == NT_SUCCESS(status)) { - DoTraceLevelMessage( - m_PkgPnp->GetDriverGlobals(), - TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE 0x%p !devobj 0x%p Device Power Requirement State Machine" - " Initialize() failed, %!STATUS!", - m_PkgPnp->GetDevice()->GetHandle(), - m_PkgPnp->GetDevice()->GetDeviceObject(), - status); - goto exit; - } +// status = fxDprMachine->Initialize(m_PkgPnp->GetDriverGlobals()); +// if (FALSE == NT_SUCCESS(status)) { +// DoTraceLevelMessage( +// m_PkgPnp->GetDriverGlobals(), +// TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE 0x%p !devobj 0x%p Device Power Requirement State Machine" +// " Initialize() failed, %!STATUS!", +// m_PkgPnp->GetDevice()->GetHandle(), +// m_PkgPnp->GetDevice()->GetDeviceObject(), +// status); +// goto exit; +// } - status = fxDprMachine->Init( - m_PkgPnp, - FxDevicePwrRequirementMachine::_ProcessEventInner - ); - if (!NT_SUCCESS(status)) { - DoTraceLevelMessage( - m_PkgPnp->GetDriverGlobals(), - TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE 0x%p !devobj 0x%p Device Power Requirement State Machine" - " Init() failed, %!STATUS!", - m_PkgPnp->GetDevice()->GetHandle(), - m_PkgPnp->GetDevice()->GetDeviceObject(), - status); - goto exit; - } +// status = fxDprMachine->Init( +// m_PkgPnp, +// FxDevicePwrRequirementMachine::_ProcessEventInner +// ); +// if (!NT_SUCCESS(status)) { +// DoTraceLevelMessage( +// m_PkgPnp->GetDriverGlobals(), +// TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE 0x%p !devobj 0x%p Device Power Requirement State Machine" +// " Init() failed, %!STATUS!", +// m_PkgPnp->GetDevice()->GetHandle(), +// m_PkgPnp->GetDevice()->GetDeviceObject(), +// status); +// goto exit; +// } - m_DevicePowerRequirementMachine = fxDprMachine; +// m_DevicePowerRequirementMachine = fxDprMachine; - status = STATUS_SUCCESS; +// status = STATUS_SUCCESS; -exit: - if (FALSE == NT_SUCCESS(status)) { - if (NULL != fxDprMachine) { - delete fxDprMachine; - } - } - return status; +// exit: +// if (FALSE == NT_SUCCESS(status)) { +// if (NULL != fxDprMachine) { +// delete fxDprMachine; +// } +// } +// return status; + ROSWDFNOTIMPLEMENTED; + return STATUS_SUCCESS; } NTSTATUS @@ -112,121 +114,123 @@ FxPoxInterface::InitializeComponents( VOID ) { - NTSTATUS status; - PPOX_SETTINGS poxSettings = NULL; - WDFDEVICE fxDevice = NULL; +// NTSTATUS status; +// PPOX_SETTINGS poxSettings = NULL; +// WDFDEVICE fxDevice = NULL; - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. Nothing to do. - // - return STATUS_SUCCESS; - } +// if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. +// m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { +// // +// // Driver-managed idle timeout. Nothing to do. +// // +// return STATUS_SUCCESS; +// } - // - // We create the device power requirement state machine only if system- - // managed idle timeout is being used. - // - if (NULL == m_DevicePowerRequirementMachine) { - status = CreateDevicePowerRequirementMachine(); - if (FALSE == NT_SUCCESS(status)) { - goto exit; - } - } +// // +// // We create the device power requirement state machine only if system- +// // managed idle timeout is being used. +// // +// if (NULL == m_DevicePowerRequirementMachine) { +// status = CreateDevicePowerRequirementMachine(); +// if (FALSE == NT_SUCCESS(status)) { +// goto exit; +// } +// } - ASSERT(NULL != m_DevicePowerRequirementMachine); +// ASSERT(NULL != m_DevicePowerRequirementMachine); - // - // Register with the power framework - // - status = PoxRegisterDevice(); +// // +// // Register with the power framework +// // +// status = PoxRegisterDevice(); - if (FALSE == NT_SUCCESS(status)) { - DoTraceLevelMessage( - m_PkgPnp->GetDriverGlobals(), - TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE 0x%p !devobj 0x%p FxPox::PoxRegisterDevice failed. " - "%!STATUS!.", - m_PkgPnp->GetDevice()->GetHandle(), - m_PkgPnp->GetDevice()->GetDeviceObject(), - status); - goto exit; - } +// if (FALSE == NT_SUCCESS(status)) { +// DoTraceLevelMessage( +// m_PkgPnp->GetDriverGlobals(), +// TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE 0x%p !devobj 0x%p FxPox::PoxRegisterDevice failed. " +// "%!STATUS!.", +// m_PkgPnp->GetDevice()->GetHandle(), +// m_PkgPnp->GetDevice()->GetDeviceObject(), +// status); +// goto exit; +// } - // - // At the time of registration, all components are active. When we start the - // power framework's device power management (see below), all components are - // moved to the idle state by default. Take an extra reference on the - // component to prevent this from happening. The power policy state machine - // will evaluate the S0-idle policy later and ask us to drop this reference - // if the policy requires it. - // - PoxActivateComponent(); +// // +// // At the time of registration, all components are active. When we start the +// // power framework's device power management (see below), all components are +// // moved to the idle state by default. Take an extra reference on the +// // component to prevent this from happening. The power policy state machine +// // will evaluate the S0-idle policy later and ask us to drop this reference +// // if the policy requires it. +// // +// PoxActivateComponent(); - // - // Tell the power framework to start its device power management. This will - // drop a reference on the component, but the component will still remain - // active because of the extra reference we took above. - // - PoxStartDevicePowerManagement(); +// // +// // Tell the power framework to start its device power management. This will +// // drop a reference on the component, but the component will still remain +// // active because of the extra reference we took above. +// // +// PoxStartDevicePowerManagement(); - // - // If the client driver has specified power framework settings, retrieve - // them. - // - poxSettings = GetPowerFrameworkSettings(); +// // +// // If the client driver has specified power framework settings, retrieve +// // them. +// // +// poxSettings = GetPowerFrameworkSettings(); - // - // If the driver wanted to receive the POHANDLE, invoke their callback now - // - if ((NULL != poxSettings) && - (NULL != poxSettings->EvtDeviceWdmPostPoFxRegisterDevice)) { +// // +// // If the driver wanted to receive the POHANDLE, invoke their callback now +// // +// if ((NULL != poxSettings) && +// (NULL != poxSettings->EvtDeviceWdmPostPoFxRegisterDevice)) { - fxDevice = m_PkgPnp->GetDevice()->GetHandle(); +// fxDevice = m_PkgPnp->GetDevice()->GetHandle(); - status = poxSettings->EvtDeviceWdmPostPoFxRegisterDevice( - fxDevice, - m_PoHandle - ); - if (FALSE == NT_SUCCESS(status)) { +// status = poxSettings->EvtDeviceWdmPostPoFxRegisterDevice( +// fxDevice, +// m_PoHandle +// ); +// if (FALSE == NT_SUCCESS(status)) { - DoTraceLevelMessage( - m_PkgPnp->GetDriverGlobals(), - TRACE_LEVEL_ERROR, TRACINGPNP, - "WDFDEVICE 0x%p !devobj 0x%p. The client driver has failed the " - "EvtDeviceWdmPostPoFxRegisterDevice callback with %!STATUS!.", - m_PkgPnp->GetDevice()->GetHandle(), - m_PkgPnp->GetDevice()->GetDeviceObject(), - status); +// DoTraceLevelMessage( +// m_PkgPnp->GetDriverGlobals(), +// TRACE_LEVEL_ERROR, TRACINGPNP, +// "WDFDEVICE 0x%p !devobj 0x%p. The client driver has failed the " +// "EvtDeviceWdmPostPoFxRegisterDevice callback with %!STATUS!.", +// m_PkgPnp->GetDevice()->GetHandle(), +// m_PkgPnp->GetDevice()->GetDeviceObject(), +// status); - // - // Notify the driver that the POHANDLE is about to become invalid - // - if (NULL != poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice) { - poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice( - fxDevice, - m_PoHandle - ); - } +// // +// // Notify the driver that the POHANDLE is about to become invalid +// // +// if (NULL != poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice) { +// poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice( +// fxDevice, +// m_PoHandle +// ); +// } - // - // Unregister with the power framework - // - PoxUnregisterDevice(); - goto exit; - } - } +// // +// // Unregister with the power framework +// // +// PoxUnregisterDevice(); +// goto exit; +// } +// } - // - // Tell the device power requirement state machine that we have registered - // with the power framework - // - m_DevicePowerRequirementMachine->ProcessEvent(DprEventRegisteredWithPox); +// // +// // Tell the device power requirement state machine that we have registered +// // with the power framework +// // +// m_DevicePowerRequirementMachine->ProcessEvent(DprEventRegisteredWithPox); -exit: - return status; +// exit: +// return status; + ROSWDFNOTIMPLEMENTED; + return STATUS_SUCCESS; } VOID @@ -234,49 +238,50 @@ FxPoxInterface::UninitializeComponents( VOID ) { - PPOX_SETTINGS poxSettings = NULL; + // PPOX_SETTINGS poxSettings = NULL; - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. Nothing to do. - // - return; - } + // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. + // m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { + // // + // // Driver-managed idle timeout. Nothing to do. + // // + // return; + // } - ASSERT(NULL != m_DevicePowerRequirementMachine); + // ASSERT(NULL != m_DevicePowerRequirementMachine); - // - // If the client driver has specified power framework settings, retrieve - // them. - // - poxSettings = GetPowerFrameworkSettings(); + // // + // // If the client driver has specified power framework settings, retrieve + // // them. + // // + // poxSettings = GetPowerFrameworkSettings(); - // - // Notify the client driver that the POHANDLE is about to become invalid - // - if ((NULL != poxSettings) && - (NULL != poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice)) { + // // + // // Notify the client driver that the POHANDLE is about to become invalid + // // + // if ((NULL != poxSettings) && + // (NULL != poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice)) { - poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice( - m_PkgPnp->GetDevice()->GetHandle(), - m_PoHandle - ); - } + // poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice( + // m_PkgPnp->GetDevice()->GetHandle(), + // m_PoHandle + // ); + // } - // - // Unregister with the power framework - // - PoxUnregisterDevice(); + // // + // // Unregister with the power framework + // // + // PoxUnregisterDevice(); - // - // Tell the device power requirement state machine that we have unregistered - // with the power framework - // - m_DevicePowerRequirementMachine->ProcessEvent( - DprEventUnregisteredWithPox - ); - return; + // // + // // Tell the device power requirement state machine that we have unregistered + // // with the power framework + // // + // m_DevicePowerRequirementMachine->ProcessEvent( + // DprEventUnregisteredWithPox + // ); + // return; + ROSWDFNOTIMPLEMENTED; } VOID @@ -284,16 +289,17 @@ FxPoxInterface::RequestComponentActive( VOID ) { - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. Nothing to do. - // - return; - } + // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. + // m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { + // // + // // Driver-managed idle timeout. Nothing to do. + // // + // return; + // } - PoxActivateComponent(); - return; + // PoxActivateComponent(); + // return; + ROSWDFNOTIMPLEMENTED; } BOOLEAN @@ -301,29 +307,31 @@ FxPoxInterface::DeclareComponentIdle( VOID ) { - BOOLEAN canPowerDown; + // BOOLEAN canPowerDown; - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. We can power down immediately, without - // waiting for device-power-not-required notification. - // - canPowerDown = TRUE; - } else { - // - // System-managed idle timeout - // - PoxIdleComponent(); + // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. + // m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { + // // + // // Driver-managed idle timeout. We can power down immediately, without + // // waiting for device-power-not-required notification. + // // + // canPowerDown = TRUE; + // } else { + // // + // // System-managed idle timeout + // // + // PoxIdleComponent(); - // - // We must wait for device-power-not-required notification before - // powering down. - // - canPowerDown = FALSE; - } + // // + // // We must wait for device-power-not-required notification before + // // powering down. + // // + // canPowerDown = FALSE; + // } - return canPowerDown; + // return canPowerDown; + ROSWDFNOTIMPLEMENTED; + return TRUE; } VOID @@ -331,27 +339,28 @@ FxPoxInterface::UpdateIdleTimeoutHint( VOID ) { - ULONGLONG idleTimeoutHint; + // ULONGLONG idleTimeoutHint; - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. Nothing to do. - // - return; - } + // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. + // m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { + // // + // // Driver-managed idle timeout. Nothing to do. + // // + // return; + // } - if (m_NextIdleTimeoutHint != m_CurrentIdleTimeoutHint) { - m_CurrentIdleTimeoutHint = m_NextIdleTimeoutHint; + // if (m_NextIdleTimeoutHint != m_CurrentIdleTimeoutHint) { + // m_CurrentIdleTimeoutHint = m_NextIdleTimeoutHint; - // - // Convert the idle timeout from milliseconds to 100-nanosecond units - // - idleTimeoutHint = ((ULONGLONG) m_CurrentIdleTimeoutHint) * 10 * 1000; - PoxSetDeviceIdleTimeout(idleTimeoutHint); - } + // // + // // Convert the idle timeout from milliseconds to 100-nanosecond units + // // + // idleTimeoutHint = ((ULONGLONG) m_CurrentIdleTimeoutHint) * 10 * 1000; + // PoxSetDeviceIdleTimeout(idleTimeoutHint); + // } - return; + // return; + ROSWDFNOTIMPLEMENTED; } @@ -360,52 +369,54 @@ FxPoxInterface::NotifyDevicePowerDown( VOID ) { - KIRQL irql; - BOOLEAN canPowerOff; + // KIRQL irql; + // BOOLEAN canPowerOff; - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. We don't have to take power framework's - // device power requirement into consideration. Just return success. - // - return STATUS_SUCCESS; - } + // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. + // m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { + // // + // // Driver-managed idle timeout. We don't have to take power framework's + // // device power requirement into consideration. Just return success. + // // + // return STATUS_SUCCESS; + // } - // - // Acquire the lock to ensure that device power requirement doesn't change. - // - m_DevicePowerRequiredLock.Acquire(&irql); - if (FALSE == m_DevicePowerRequired) { - // - // Send an event to the device power requirement state machine to tell - // it that we are about to go to Dx. - // - // We send the event inside a lock in order to handle the race condition - // when the power framework notifies us that device power is required at - // the same time that we are about to go to Dx. By sending the event - // inside the lock, we ensure that the DprEventDeviceGoingToDx event is - // always queued to device power requirement state machine before the - // DprEventPoxRequiresPower. - // - // This allows for a clean design in the device power requirement state - // machine by ensuring that it does not have to handle a non-intuitive - // sequence, i.e. DprEventPoxRequiresPower followed by - // DprEventDeviceGoingToDx. This sequence is non-intuitive because it - // doesn't make sense for a device to go to Dx after it has been - // informed that device power is required. Avoiding this non-intuitive - // sequence via locking enables a clean design for the device power - // requirement state machine. - // - m_DevicePowerRequirementMachine->ProcessEvent(DprEventDeviceGoingToDx); - canPowerOff = TRUE; + // // + // // Acquire the lock to ensure that device power requirement doesn't change. + // // + // m_DevicePowerRequiredLock.Acquire(&irql); + // if (FALSE == m_DevicePowerRequired) { + // // + // // Send an event to the device power requirement state machine to tell + // // it that we are about to go to Dx. + // // + // // We send the event inside a lock in order to handle the race condition + // // when the power framework notifies us that device power is required at + // // the same time that we are about to go to Dx. By sending the event + // // inside the lock, we ensure that the DprEventDeviceGoingToDx event is + // // always queued to device power requirement state machine before the + // // DprEventPoxRequiresPower. + // // + // // This allows for a clean design in the device power requirement state + // // machine by ensuring that it does not have to handle a non-intuitive + // // sequence, i.e. DprEventPoxRequiresPower followed by + // // DprEventDeviceGoingToDx. This sequence is non-intuitive because it + // // doesn't make sense for a device to go to Dx after it has been + // // informed that device power is required. Avoiding this non-intuitive + // // sequence via locking enables a clean design for the device power + // // requirement state machine. + // // + // m_DevicePowerRequirementMachine->ProcessEvent(DprEventDeviceGoingToDx); + // canPowerOff = TRUE; - } else { - canPowerOff = FALSE; - } - m_DevicePowerRequiredLock.Release(irql); + // } else { + // canPowerOff = FALSE; + // } + // m_DevicePowerRequiredLock.Release(irql); - return canPowerOff ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL; + // return canPowerOff ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL; + ROSWDFNOTIMPLEMENTED; + return STATUS_SUCCESS; } VOID @@ -413,23 +424,23 @@ FxPoxInterface::DeviceIsPoweredOn( VOID ) { + ROSWDFNOTIMPLEMENTED; + // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. + // m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { + // // + // // Driver-managed idle timeout. Nothing to do. + // // + // return; + // } - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. Nothing to do. - // - return; - } - - // - // System-managed idle timeout. Notify the device power requirement state - // machine that we are back in D0. - // - m_DevicePowerRequirementMachine->ProcessEvent( - DprEventDeviceReturnedToD0 - ); - return; + // // + // // System-managed idle timeout. Notify the device power requirement state + // // machine that we are back in D0. + // // + // m_DevicePowerRequirementMachine->ProcessEvent( + // DprEventDeviceReturnedToD0 + // ); + // return; } PPOX_SETTINGS @@ -439,14 +450,15 @@ FxPoxInterface::GetPowerFrameworkSettings( { PPOX_SETTINGS poxSettings = NULL; - if (m_PkgPnp->m_PowerPolicyMachine.m_Owner-> - m_IdleSettings.m_TimeoutMgmt.DriverSpecifiedPowerFrameworkSettings()) { + ROSWDFNOTIMPLEMENTED; + // if (m_PkgPnp->m_PowerPolicyMachine.m_Owner-> + // m_IdleSettings.m_TimeoutMgmt.DriverSpecifiedPowerFrameworkSettings()) { - poxSettings = m_PkgPnp->m_PowerPolicyMachine.m_Owner-> - m_IdleSettings.m_TimeoutMgmt.GetPowerFrameworkSettings(); + // poxSettings = m_PkgPnp->m_PowerPolicyMachine.m_Owner-> + // m_IdleSettings.m_TimeoutMgmt.GetPowerFrameworkSettings(); - ASSERT(NULL != poxSettings); - } + // ASSERT(NULL != poxSettings); + // } return poxSettings; } @@ -456,27 +468,28 @@ FxPoxInterface::DprProcessEventFromPoxCallback( __in FxDevicePwrRequirementEvents Event ) { - KIRQL irql; + ROSWDFNOTIMPLEMENTED; + // KIRQL irql; - // - // We should not run the state machine from within a power framework - // callback because we might end up reaching a state where we unregister - // with the power framework. Unregistering from a callback leads to a - // deadlock. Therefore, we raise IRQL before queueing an event to the state - // machine. Raising IRQL causes the event processing to be deferred to a - // worker thread. - // + // // + // // We should not run the state machine from within a power framework + // // callback because we might end up reaching a state where we unregister + // // with the power framework. Unregistering from a callback leads to a + // // deadlock. Therefore, we raise IRQL before queueing an event to the state + // // machine. Raising IRQL causes the event processing to be deferred to a + // // worker thread. + // // - // - // This path should only be invoked for kernel mode. For user mode, this - // condition is avoided by reflector guranteeing that it queues a worker - // item to send a Pofx event corresponding to any PoFx callback - // - ASSERT(FX_IS_KERNEL_MODE); + // // + // // This path should only be invoked for kernel mode. For user mode, this + // // condition is avoided by reflector guranteeing that it queues a worker + // // item to send a Pofx event corresponding to any PoFx callback + // // + // ASSERT(FX_IS_KERNEL_MODE); - Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql); - m_DevicePowerRequirementMachine->ProcessEvent(Event); - Mx::MxLowerIrql(irql); + // Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql); + // m_DevicePowerRequirementMachine->ProcessEvent(Event); + // Mx::MxLowerIrql(irql); } VOID @@ -484,21 +497,21 @@ FxPoxInterface::SimulateDevicePowerRequired( VOID ) { + ROSWDFNOTIMPLEMENTED; + // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. + // m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { + // // + // // Driver-managed idle timeout. Nothing to do. + // // + // return; + // } - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. Nothing to do. - // - return; - } - - // - // System-managed idle timeout. Notify the device power requirement state - // machine that device power is required. - // - PowerRequiredCallbackWorker(FALSE /* InvokedFromPoxCallback */); - return; + // // + // // System-managed idle timeout. Notify the device power requirement state + // // machine that device power is required. + // // + // PowerRequiredCallbackWorker(FALSE /* InvokedFromPoxCallback */); + // return; } VOID @@ -506,21 +519,21 @@ FxPoxInterface::SimulateDevicePowerNotRequired( VOID ) { + ROSWDFNOTIMPLEMENTED; + // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. + // m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { + // // + // // Driver-managed idle timeout. Nothing to do. + // // + // return; + // } - if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings. - m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) { - // - // Driver-managed idle timeout. Nothing to do. - // - return; - } - - // - // System-managed idle timeout. Notify the device power requirement state - // machine that device power is not required. - // - PowerNotRequiredCallbackWorker(FALSE /* InvokedFromPoxCallback */); - return; + // // + // // System-managed idle timeout. Notify the device power requirement state + // // machine that device power is not required. + // // + // PowerNotRequiredCallbackWorker(FALSE /* InvokedFromPoxCallback */); + // return; } VOID @@ -528,25 +541,26 @@ FxPoxInterface::PowerRequiredCallbackWorker( __in BOOLEAN InvokedFromPoxCallback ) { - KIRQL irql; + ROSWDFNOTIMPLEMENTED; + // KIRQL irql; - // - // Make a note of the fact that device power is required - // - m_DevicePowerRequiredLock.Acquire(&irql); - m_DevicePowerRequired = TRUE; - m_DevicePowerRequiredLock.Release(irql); + // // + // // Make a note of the fact that device power is required + // // + // m_DevicePowerRequiredLock.Acquire(&irql); + // m_DevicePowerRequired = TRUE; + // m_DevicePowerRequiredLock.Release(irql); - // - // Send the device-power-required event to the device power requirement - // state machine. - // - if (InvokedFromPoxCallback) { - DprProcessEventFromPoxCallback(DprEventPoxRequiresPower); - } else { - m_DevicePowerRequirementMachine->ProcessEvent(DprEventPoxRequiresPower); - } - return; + // // + // // Send the device-power-required event to the device power requirement + // // state machine. + // // + // if (InvokedFromPoxCallback) { + // DprProcessEventFromPoxCallback(DprEventPoxRequiresPower); + // } else { + // m_DevicePowerRequirementMachine->ProcessEvent(DprEventPoxRequiresPower); + // } + // return; } VOID @@ -554,26 +568,27 @@ FxPoxInterface::PowerNotRequiredCallbackWorker( __in BOOLEAN InvokedFromPoxCallback ) { - KIRQL irql; + ROSWDFNOTIMPLEMENTED; + // KIRQL irql; - // - // Make a note of the fact that device power is not required - // - m_DevicePowerRequiredLock.Acquire(&irql); - m_DevicePowerRequired = FALSE; - m_DevicePowerRequiredLock.Release(irql); + // // + // // Make a note of the fact that device power is not required + // // + // m_DevicePowerRequiredLock.Acquire(&irql); + // m_DevicePowerRequired = FALSE; + // m_DevicePowerRequiredLock.Release(irql); - // - // Send the device-power-not-required event to the device power - // requirement state machine. - // - if (InvokedFromPoxCallback) { - DprProcessEventFromPoxCallback(DprEventPoxDoesNotRequirePower); - } else { - m_DevicePowerRequirementMachine->ProcessEvent( - DprEventPoxDoesNotRequirePower - ); - } - return; + // // + // // Send the device-power-not-required event to the device power + // // requirement state machine. + // // + // if (InvokedFromPoxCallback) { + // DprProcessEventFromPoxCallback(DprEventPoxDoesNotRequirePower); + // } else { + // m_DevicePowerRequirementMachine->ProcessEvent( + // DprEventPoxDoesNotRequirePower + // ); + // } + // return; } diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgfdoum.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgfdoum.cpp index d5ec1e54e9e..7bb6426c292 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgfdoum.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgfdoum.cpp @@ -26,7 +26,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include #include diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpdoum.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpdoum.cpp index 69982860a0c..432b493ff89 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpdoum.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpdoum.cpp @@ -20,7 +20,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include // Tracing support diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpnpum.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpnpum.cpp index 622d16168bf..e3d008a53e6 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpnpum.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpnpum.cpp @@ -1,7 +1,7 @@ // // Copyright (C) Microsoft. All rights reserved. // -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include #include diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/pnpstatemachineum.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/pnpstatemachineum.cpp index 011c8a131bb..e77bf2ef87e 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/pnpstatemachineum.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/pnpstatemachineum.cpp @@ -25,7 +25,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" extern "C" { #if defined(EVENT_TRACING) diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerpolicystatemachineum.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerpolicystatemachineum.cpp index d5e6ecce8f0..2ec069173e7 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerpolicystatemachineum.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerpolicystatemachineum.cpp @@ -17,7 +17,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include "FxUsbIdleInfo.hpp" diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerstatemachineum.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerstatemachineum.cpp index 98809bf301c..8f0410d2ada 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerstatemachineum.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerstatemachineum.cpp @@ -24,7 +24,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" extern "C" { #if defined(EVENT_TRACING) diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/poxinterfaceum.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/poxinterfaceum.cpp index 65763a58c92..b82c7531b29 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/poxinterfaceum.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/poxinterfaceum.cpp @@ -1,7 +1,7 @@ // // Copyright (C) Microsoft. All rights reserved. // -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" #include #include diff --git a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/supportum.cpp b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/supportum.cpp index a8b8771221d..24c39e16db8 100644 --- a/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/supportum.cpp +++ b/sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/supportum.cpp @@ -21,7 +21,7 @@ Revision History: --*/ -#include "..\pnppriv.hpp" +#include "../pnppriv.hpp" VOID CopyQueryInterfaceToIrpStack( diff --git a/sdk/lib/drivers/wdf/shared/object/dbgtrace.cpp b/sdk/lib/drivers/wdf/shared/object/dbgtrace.cpp index 95bb4849237..b483d2da94f 100644 --- a/sdk/lib/drivers/wdf/shared/object/dbgtrace.cpp +++ b/sdk/lib/drivers/wdf/shared/object/dbgtrace.cpp @@ -109,7 +109,7 @@ Return Value: (DebugPrintLevel <= DebugLevel && ((DebugPrintFlag & DebugFlag) == DebugPrintFlag))) { #if FX_CORE_MODE==FX_CORE_KERNEL_MODE - DbgPrint("WDFTrace: %s", debugMessageBuffer); + DbgPrint("WDFTrace: %s\n", debugMessageBuffer); #else OutputDebugString("WDFTrace: "); OutputDebugString(DebugMessage); diff --git a/sdk/lib/drivers/wdf/shared/object/fxobjectapi.cpp b/sdk/lib/drivers/wdf/shared/object/fxobjectapi.cpp index 004b48eacbc..55fe16b3806 100644 --- a/sdk/lib/drivers/wdf/shared/object/fxobjectapi.cpp +++ b/sdk/lib/drivers/wdf/shared/object/fxobjectapi.cpp @@ -36,6 +36,7 @@ extern "C" { __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectReferenceActual)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -81,6 +82,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectDereferenceActual)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -170,6 +172,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectAcquireLock)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -229,6 +232,7 @@ WDFEXPORT(WdfObjectAcquireLock)( __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectReleaseLock)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -284,6 +288,7 @@ WDFEXPORT(WdfObjectReleaseLock)( __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI VOID +STDCALL WDFEXPORT(WdfObjectDelete)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -322,6 +327,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfObjectQuery)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/object/fxobjectpch.hpp b/sdk/lib/drivers/wdf/shared/object/fxobjectpch.hpp index 76d82ce2b16..a7c47378c24 100644 --- a/sdk/lib/drivers/wdf/shared/object/fxobjectpch.hpp +++ b/sdk/lib/drivers/wdf/shared/object/fxobjectpch.hpp @@ -25,6 +25,6 @@ Revision History: #include "objectpriv.hpp" #include "fxmin.hpp" -#include "FxToObjectItf.hpp" +#include "fxtoobjectitf.hpp" #endif // __FX_CORE_PCH_H__ diff --git a/sdk/lib/drivers/wdf/shared/object/fxtagtracker.cpp b/sdk/lib/drivers/wdf/shared/object/fxtagtracker.cpp index fb301e67c4d..b53bf75fc02 100644 --- a/sdk/lib/drivers/wdf/shared/object/fxtagtracker.cpp +++ b/sdk/lib/drivers/wdf/shared/object/fxtagtracker.cpp @@ -39,6 +39,7 @@ extern "C" { extern _Success_(return != 0) USHORT +STDCALL RtlCaptureStackBackTrace( _In_ ULONG FramesToSkip, _In_ ULONG FramesToCapture, diff --git a/sdk/lib/drivers/wdf/shared/object/fxuserobject.cpp b/sdk/lib/drivers/wdf/shared/object/fxuserobject.cpp index 0d9f7963efa..83b3cac20d8 100644 --- a/sdk/lib/drivers/wdf/shared/object/fxuserobject.cpp +++ b/sdk/lib/drivers/wdf/shared/object/fxuserobject.cpp @@ -32,7 +32,7 @@ Revision History: #include "fxobjectpch.hpp" -#include "FxUserObject.hpp" +#include "fxuserobject.hpp" // Tracing support extern "C" { diff --git a/sdk/lib/drivers/wdf/shared/object/fxuserobjectapi.cpp b/sdk/lib/drivers/wdf/shared/object/fxuserobjectapi.cpp index 85eea814685..91b6a1939d5 100644 --- a/sdk/lib/drivers/wdf/shared/object/fxuserobjectapi.cpp +++ b/sdk/lib/drivers/wdf/shared/object/fxuserobjectapi.cpp @@ -24,7 +24,7 @@ Revision History: #include "fxobjectpch.hpp" -#include "FxUserObject.hpp" +#include "fxuserobject.hpp" // Tracing support extern "C" { @@ -39,6 +39,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfObjectCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/object/fxverifierbugcheck.cpp b/sdk/lib/drivers/wdf/shared/object/fxverifierbugcheck.cpp index 2fcffcbd0c4..52b1e193dc8 100644 --- a/sdk/lib/drivers/wdf/shared/object/fxverifierbugcheck.cpp +++ b/sdk/lib/drivers/wdf/shared/object/fxverifierbugcheck.cpp @@ -39,8 +39,8 @@ extern "C" { //============================================================================= +DECLSPEC_NORETURN VOID -__declspec(noreturn) FxVerifierBugCheckWorker( __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDF_BUGCHECK_CODES WdfBugCheckCode, @@ -72,8 +72,8 @@ Returns: (ULONG_PTR) FxDriverGlobals ); } +DECLSPEC_NORETURN VOID -__declspec(noreturn) FxVerifierNullBugCheck( __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PVOID ReturnAddress diff --git a/sdk/lib/drivers/wdf/shared/object/globals.cpp b/sdk/lib/drivers/wdf/shared/object/globals.cpp index fcc0815be17..459e93f1596 100644 --- a/sdk/lib/drivers/wdf/shared/object/globals.cpp +++ b/sdk/lib/drivers/wdf/shared/object/globals.cpp @@ -289,7 +289,7 @@ FxDriverGlobalsInitializeDebugExtension( return; } - RtlZeroMemory(pExtension, sizeof(*pExtension)); + *pExtension = {}; pExtension->AllocatedTagTrackersLock.Initialize(); @@ -678,7 +678,7 @@ FxLibraryGlobalsCommission( // Register for the global (library) bugcheck callbacks. // FxInitializeBugCheckDriverInfo(); - +#ifdef EVENT_TRACING // __REACTOS__ // // Init driver usage tracker. This tracker is used by the debug dump // callback routines for finding the driver's dump log file to write @@ -728,7 +728,9 @@ FxLibraryGlobalsCommission( // ASSERT(FxLibraryGlobals.PerfTraceRoutines->Size >= sizeof(WMI_WDF_NOTIFY_ROUTINES)); - +#else + status = STATUS_SUCCESS; // __REACTOS__ +#endif // EVENT_TRACING #else status = STATUS_SUCCESS; #endif @@ -810,7 +812,7 @@ LockVerifierSection( // VerifierLockHandle is a function that we use to lock in all the code from it's section // since all the verifier code is in the same section as VerifierLockHandle. // - FxLibraryGlobals.VerifierSectionHandle = MmLockPagableCodeSection(VerifierPageLockHandle); + FxLibraryGlobals.VerifierSectionHandle = MmLockPagableCodeSection((PVOID)VerifierPageLockHandle); } else { MmLockPagableSectionByHandle(FxLibraryGlobals.VerifierSectionHandle); @@ -898,7 +900,7 @@ Returns: // // Initialize IFR logging // - FxIFRStart(FxDriverGlobals, RegistryPath, DriverObject); + // FxIFRStart(FxDriverGlobals, RegistryPath, DriverObject); __REACTOS__ DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDRIVER, "Initialize globals for %!wZ!", RegistryPath); @@ -912,7 +914,7 @@ Returns: // FxPoolPackageInitialize logs a message in case of failure so // we don't need to log failure here. // - FxIFRStop(FxDriverGlobals); + // FxIFRStop(FxDriverGlobals); __REACTOS__ return status; } @@ -1002,7 +1004,7 @@ Returns: // // Release the last reference. // - FxDriverGlobals->RELEASE(FxDestroy); + FxDriverGlobals->RELEASE((PVOID)FxDestroy); // // Wait for everyone else to be done. @@ -1052,7 +1054,7 @@ FxAllocateDriverGlobals( ) { PFX_DRIVER_GLOBALS pFxDriverGlobals; - KIRQL irql; + // KIRQL irql; NTSTATUS status; pFxDriverGlobals = (PFX_DRIVER_GLOBALS) @@ -1062,7 +1064,7 @@ FxAllocateDriverGlobals( return NULL; } - RtlZeroMemory(pFxDriverGlobals, sizeof(FX_DRIVER_GLOBALS)); + *pFxDriverGlobals = {}; pFxDriverGlobals->Refcnt = 1; @@ -1079,10 +1081,12 @@ FxAllocateDriverGlobals( // // Initialize this new FxDriverGlobals structure. // +#ifndef __REACTOS__ FxLibraryGlobals.FxDriverGlobalsListLock.Acquire(&irql); InsertHeadList(&FxLibraryGlobals.FxDriverGlobalsList, &pFxDriverGlobals->Linkage); FxLibraryGlobals.FxDriverGlobalsListLock.Release(irql); +#endif pFxDriverGlobals->WdfHandleMask = FxHandleValueMask; pFxDriverGlobals->WdfVerifierAllocateFailCount = (ULONG) -1; @@ -1140,7 +1144,8 @@ FxAllocateDriverGlobals( pFxDriverGlobals->FxForceLogsInMiniDump = FALSE; #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE) - pFxDriverGlobals->FxTrackDriverForMiniDumpLog = TRUE; + // pFxDriverGlobals->FxTrackDriverForMiniDumpLog = TRUE; + pFxDriverGlobals->FxTrackDriverForMiniDumpLog = FALSE; // __REACTOS__ pFxDriverGlobals->IsUserModeDriver = FALSE; #else pFxDriverGlobals->FxTrackDriverForMiniDumpLog = FALSE; @@ -1163,9 +1168,11 @@ FxAllocateDriverGlobals( // Allocate a telemetry context if a telemetry client is enabled, for any level/keyword. // pFxDriverGlobals->TelemetryContext = NULL; +#ifdef EVENT_TRACING // __REACTOS__ if (TraceLoggingProviderEnabled(g_TelemetryProvider, 0 ,0)) { AllocAndInitializeTelemetryContext(&(pFxDriverGlobals->TelemetryContext)); } +#endif return &pFxDriverGlobals->Public; } diff --git a/sdk/lib/drivers/wdf/shared/object/handleapi.cpp b/sdk/lib/drivers/wdf/shared/object/handleapi.cpp index 18db36b0d7f..e65c411f964 100644 --- a/sdk/lib/drivers/wdf/shared/object/handleapi.cpp +++ b/sdk/lib/drivers/wdf/shared/object/handleapi.cpp @@ -504,6 +504,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfObjectAllocateContext)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/object/km/globalskm.cpp b/sdk/lib/drivers/wdf/shared/object/km/globalskm.cpp index 41de43d0013..2cf6d9a4036 100644 --- a/sdk/lib/drivers/wdf/shared/object/km/globalskm.cpp +++ b/sdk/lib/drivers/wdf/shared/object/km/globalskm.cpp @@ -6,10 +6,10 @@ // Tracing support extern "C" { #if defined(EVENT_TRACING) -#include "GlobalsKm.tmh" +#include "globalskm.tmh" #endif -#include +// #include #include @@ -45,6 +45,7 @@ __drv_minIRQL(DISPATCH_LEVEL) __drv_requiresIRQL(DISPATCH_LEVEL) __drv_sameIRQL VOID +STDCALL FxFlushDpc ( __in struct _KDPC *Dpc, __in_opt PVOID DeferredContext, diff --git a/sdk/lib/drivers/wdf/shared/object/km/wdfpoolkm.cpp b/sdk/lib/drivers/wdf/shared/object/km/wdfpoolkm.cpp index 8795026a03e..0043de8a3e0 100644 --- a/sdk/lib/drivers/wdf/shared/object/km/wdfpoolkm.cpp +++ b/sdk/lib/drivers/wdf/shared/object/km/wdfpoolkm.cpp @@ -41,6 +41,7 @@ extern "C" { __drv_maxIRQL(DISPATCH_LEVEL) NTKERNELAPI PMDL +STDCALL IoAllocateMdl( __in_opt __drv_aliasesMem PVOID VirtualAddress, __in ULONG Length, @@ -52,6 +53,7 @@ IoAllocateMdl( __drv_maxIRQL(DISPATCH_LEVEL) NTKERNELAPI VOID +STDCALL IoFreeMdl( PMDL Mdl ); diff --git a/sdk/lib/drivers/wdf/shared/object/um/fxobjectinfoum.cpp b/sdk/lib/drivers/wdf/shared/object/um/fxobjectinfoum.cpp index 9af6f6da48f..4e8921fc693 100644 --- a/sdk/lib/drivers/wdf/shared/object/um/fxobjectinfoum.cpp +++ b/sdk/lib/drivers/wdf/shared/object/um/fxobjectinfoum.cpp @@ -1,10 +1,10 @@ // // Copyright (C) Microsoft. All rights reserved. // -#include "FxMin.hpp" +#include "fxmin.hpp" #include "fxobjectpch.hpp" -#include "FxUserObject.hpp" +#include "fxuserobject.hpp" #include "pnppriv.hpp" // diff --git a/sdk/lib/drivers/wdf/shared/object/wdfpool.cpp b/sdk/lib/drivers/wdf/shared/object/wdfpool.cpp index 0c44b688e61..c3d943725e1 100644 --- a/sdk/lib/drivers/wdf/shared/object/wdfpool.cpp +++ b/sdk/lib/drivers/wdf/shared/object/wdfpool.cpp @@ -150,7 +150,7 @@ Remarks: if (FxDriverGlobals->IsPoolTrackingOn()) { if (FxDriverGlobals->FxVerifierOn && - (FxDriverGlobals->WdfVerifierAllocateFailCount != 0xFFFFFFFF)) { + (FxDriverGlobals->WdfVerifierAllocateFailCount != -1L)) { // // If the registry key VerifierAllocateFailCount is set, all allocations diff --git a/sdk/lib/drivers/wdf/shared/primitives/km/mxgeneralkm.cpp b/sdk/lib/drivers/wdf/shared/primitives/km/mxgeneralkm.cpp index 4b609c9dbe1..95948dea7d2 100644 --- a/sdk/lib/drivers/wdf/shared/primitives/km/mxgeneralkm.cpp +++ b/sdk/lib/drivers/wdf/shared/primitives/km/mxgeneralkm.cpp @@ -1,7 +1,7 @@ // // Copyright (C) Microsoft. All rights reserved. // -#include "Mx.h" +#include "mx.h" VOID Mx::MxDbgPrint( diff --git a/sdk/lib/drivers/wdf/shared/primitives/um/mxdriverobjectum.cpp b/sdk/lib/drivers/wdf/shared/primitives/um/mxdriverobjectum.cpp index 17546a6f81a..f107534dcdb 100644 --- a/sdk/lib/drivers/wdf/shared/primitives/um/mxdriverobjectum.cpp +++ b/sdk/lib/drivers/wdf/shared/primitives/um/mxdriverobjectum.cpp @@ -15,7 +15,7 @@ Abstract: #include "fxmin.hpp" #include "fxldrum.h" -PVOID +PDRIVER_ADD_DEVICE MxDriverObject::GetDriverExtensionAddDevice( VOID ) diff --git a/sdk/lib/drivers/wdf/shared/primitives/um/mxgeneralum.cpp b/sdk/lib/drivers/wdf/shared/primitives/um/mxgeneralum.cpp index 5887db90998..112eb7c0eb9 100644 --- a/sdk/lib/drivers/wdf/shared/primitives/um/mxgeneralum.cpp +++ b/sdk/lib/drivers/wdf/shared/primitives/um/mxgeneralum.cpp @@ -88,6 +88,7 @@ Mx::MxBugCheckEx( FX_VERIFY(DRIVER(BadAction, BugCheckCode), TRAPMSG("UMDF verification " "faults should not call this code path")); + UNREACHABLE; } VOID diff --git a/sdk/lib/drivers/wdf/shared/support/fxcollection.cpp b/sdk/lib/drivers/wdf/shared/support/fxcollection.cpp index fffcda75334..ffa1cf9cbbd 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxcollection.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxcollection.cpp @@ -23,7 +23,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" FxCollectionInternal::FxCollectionInternal( VOID diff --git a/sdk/lib/drivers/wdf/shared/support/fxcollectionapi.cpp b/sdk/lib/drivers/wdf/shared/support/fxcollectionapi.cpp index 01b0c45b347..a8cea62bd4d 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxcollectionapi.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxcollectionapi.cpp @@ -22,10 +22,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxCollectionApi.tmh" +// #include "FxCollectionApi.tmh" } // @@ -35,6 +35,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfCollectionCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -105,6 +106,7 @@ WDFEXPORT(WdfCollectionCreate)( __drv_maxIRQL(DISPATCH_LEVEL) ULONG +STDCALL WDFEXPORT(WdfCollectionGetCount)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -133,6 +135,7 @@ WDFEXPORT(WdfCollectionGetCount)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfCollectionAdd)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -170,6 +173,7 @@ WDFEXPORT(WdfCollectionAdd)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfCollectionRemoveItem)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -225,6 +229,7 @@ WDFEXPORT(WdfCollectionRemoveItem)( __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfCollectionRemove)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -283,6 +288,7 @@ WDFEXPORT(WdfCollectionRemove)( __drv_maxIRQL(DISPATCH_LEVEL) WDFOBJECT +STDCALL WDFEXPORT(WdfCollectionGetItem)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -296,11 +302,8 @@ WDFEXPORT(WdfCollectionGetItem)( FxCollection *pCollection; FxObject *pObject; - WDFOBJECT hObject; KIRQL irql; - hObject = NULL; - FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals), Collection, FX_TYPE_COLLECTION, @@ -319,6 +322,7 @@ WDFEXPORT(WdfCollectionGetItem)( __drv_maxIRQL(DISPATCH_LEVEL) WDFOBJECT +STDCALL WDFEXPORT(WdfCollectionGetFirstItem)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -351,6 +355,7 @@ WDFEXPORT(WdfCollectionGetFirstItem)( __drv_maxIRQL(DISPATCH_LEVEL) WDFOBJECT +STDCALL WDFEXPORT(WdfCollectionGetLastItem)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/support/fxdeviceinterface.cpp b/sdk/lib/drivers/wdf/shared/support/fxdeviceinterface.cpp index 666772df448..464cae16fe8 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxdeviceinterface.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxdeviceinterface.cpp @@ -22,10 +22,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxDeviceInterface.tmh" +// #include "FxDeviceInterface.tmh" } FxDeviceInterface::FxDeviceInterface( diff --git a/sdk/lib/drivers/wdf/shared/support/fxdeviceinterfaceapi.cpp b/sdk/lib/drivers/wdf/shared/support/fxdeviceinterfaceapi.cpp index 6af050dade2..c75ebe35edd 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxdeviceinterfaceapi.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxdeviceinterfaceapi.cpp @@ -23,10 +23,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxDeviceInterfaceAPI.tmh" +// #include "FxDeviceInterfaceAPI.tmh" } // @@ -37,6 +37,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceCreateDeviceInterface)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -164,6 +165,7 @@ Done: __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfDeviceSetDeviceInterfaceState)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -271,6 +273,7 @@ WDFEXPORT(WdfDeviceSetDeviceInterfaceState)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfDeviceRetrieveDeviceInterfaceString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/support/fxdevicetext.cpp b/sdk/lib/drivers/wdf/shared/support/fxdevicetext.cpp index 86902a567e7..d815b68e692 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxdevicetext.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxdevicetext.cpp @@ -22,7 +22,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" FxDeviceText::FxDeviceText( VOID diff --git a/sdk/lib/drivers/wdf/shared/support/fxregistryapi.cpp b/sdk/lib/drivers/wdf/shared/support/fxregistryapi.cpp index 8c6efb3ad1b..e97d1be56a6 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxregistryapi.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxregistryapi.cpp @@ -22,10 +22,11 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxRegistryAPI.tmh" +// #include "FxRegistryAPI.tmh" +#define RtlSizeTToULong RtlULongPtrToULong } extern "C" { @@ -50,6 +51,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryOpenKey)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -162,6 +164,7 @@ WDFEXPORT(WdfRegistryOpenKey)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryCreateKey)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -281,6 +284,7 @@ WDFEXPORT(WdfRegistryCreateKey)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfRegistryClose)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -313,6 +317,7 @@ WDFEXPORT(WdfRegistryClose)( __drv_maxIRQL(PASSIVE_LEVEL) HANDLE +STDCALL WDFEXPORT(WdfRegistryWdmGetHandle)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -335,6 +340,7 @@ WDFEXPORT(WdfRegistryWdmGetHandle)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryRemoveKey)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -374,6 +380,7 @@ WDFEXPORT(WdfRegistryRemoveKey)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryRemoveValue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -415,6 +422,7 @@ WDFEXPORT(WdfRegistryRemoveValue)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryValue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -485,6 +493,7 @@ WDFEXPORT(WdfRegistryQueryValue)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryMemory)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -603,6 +612,7 @@ WDFEXPORT(WdfRegistryQueryMemory)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryMultiString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -786,6 +796,7 @@ WDFEXPORT(WdfRegistryQueryMultiString)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryUnicodeString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -908,6 +919,7 @@ WDFEXPORT(WdfRegistryQueryUnicodeString)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1043,6 +1055,7 @@ WDFEXPORT(WdfRegistryQueryString)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryQueryULong)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1094,6 +1107,7 @@ WDFEXPORT(WdfRegistryQueryULong)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignValue)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1147,6 +1161,7 @@ WDFEXPORT(WdfRegistryAssignValue)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignMemory)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1239,6 +1254,7 @@ WDFEXPORT(WdfRegistryAssignMemory)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignULong)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1288,6 +1304,7 @@ WDFEXPORT(WdfRegistryAssignULong)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignUnicodeString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1374,6 +1391,7 @@ WDFEXPORT(WdfRegistryAssignUnicodeString)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1433,6 +1451,7 @@ WDFEXPORT(WdfRegistryAssignString)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfRegistryAssignMultiString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/support/fxregkey.cpp b/sdk/lib/drivers/wdf/shared/support/fxregkey.cpp index 6141abd3e23..5b389ac1c60 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxregkey.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxregkey.cpp @@ -1,7 +1,7 @@ // // Copyright (C) Microsoft. All rights reserved. // -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { #if defined(EVENT_TRACING) diff --git a/sdk/lib/drivers/wdf/shared/support/fxrequestbuffer.cpp b/sdk/lib/drivers/wdf/shared/support/fxrequestbuffer.cpp index 41b4f228965..2ef85846e94 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxrequestbuffer.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxrequestbuffer.cpp @@ -22,10 +22,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxRequestBuffer.tmh" +// #include "FxRequestBuffer.tmh" } FxRequestBuffer::FxRequestBuffer( diff --git a/sdk/lib/drivers/wdf/shared/support/fxresourceapi.cpp b/sdk/lib/drivers/wdf/shared/support/fxresourceapi.cpp index 9b1071a9417..6d966d0855d 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxresourceapi.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxresourceapi.cpp @@ -22,10 +22,10 @@ Environment: Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxResourceAPI.tmh" +// #include "FxResourceAPI.tmh" } // diff --git a/sdk/lib/drivers/wdf/shared/support/fxresourcecollection.cpp b/sdk/lib/drivers/wdf/shared/support/fxresourcecollection.cpp index 58f481c2d60..e684fa98c97 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxresourcecollection.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxresourcecollection.cpp @@ -23,7 +23,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { #if defined(EVENT_TRACING) diff --git a/sdk/lib/drivers/wdf/shared/support/fxspinlock.cpp b/sdk/lib/drivers/wdf/shared/support/fxspinlock.cpp index 7adb740ffa1..f78f93f75ba 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxspinlock.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxspinlock.cpp @@ -22,11 +22,11 @@ Revision History: --*/ -#include "FxSupportPch.hpp" -#include "FxSpinLock.hpp" +#include "fxsupportpch.hpp" +#include "fxspinlock.hpp" extern "C" { -#include "FxSpinLock.tmh" +// #include "FxSpinLock.tmh" } FxSpinLock::FxSpinLock( diff --git a/sdk/lib/drivers/wdf/shared/support/fxspinlockapi.cpp b/sdk/lib/drivers/wdf/shared/support/fxspinlockapi.cpp index a9c576580ec..8d7f600bdcb 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxspinlockapi.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxspinlockapi.cpp @@ -22,11 +22,11 @@ Revision History: --*/ -#include "FxSupportPch.hpp" -#include "FxSpinLock.hpp" +#include "fxsupportpch.hpp" +#include "fxspinlock.hpp" extern "C" { -#include "FxSpinLockAPI.tmh" +// #include "FxSpinLockAPI.tmh" } // @@ -37,6 +37,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfSpinLockCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -108,6 +109,7 @@ WDFEXPORT(WdfSpinLockCreate)( __drv_raisesIRQL(DISPATCH_LEVEL) __drv_maxIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfSpinLockAcquire)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -145,6 +147,7 @@ WDFEXPORT(WdfSpinLockAcquire)( __drv_maxIRQL(DISPATCH_LEVEL) __drv_minIRQL(DISPATCH_LEVEL) VOID +STDCALL WDFEXPORT(WdfSpinLockRelease)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/support/fxstring.cpp b/sdk/lib/drivers/wdf/shared/support/fxstring.cpp index a4f0c763852..533d25b202e 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxstring.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxstring.cpp @@ -23,7 +23,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" FxString::FxString( __in PFX_DRIVER_GLOBALS FxDriverGlobals diff --git a/sdk/lib/drivers/wdf/shared/support/fxstringapi.cpp b/sdk/lib/drivers/wdf/shared/support/fxstringapi.cpp index 34f3f18b45b..d671237c7e3 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxstringapi.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxstringapi.cpp @@ -22,10 +22,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxStringAPI.tmh" +// #include "FxStringAPI.tmh" } extern "C" { @@ -33,6 +33,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfStringCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -116,6 +117,7 @@ WDFEXPORT(WdfStringCreate)( __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfStringGetUnicodeString)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/support/fxsupportpch.hpp b/sdk/lib/drivers/wdf/shared/support/fxsupportpch.hpp index 2c9fbfa7cfe..fe19d3e8e30 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxsupportpch.hpp +++ b/sdk/lib/drivers/wdf/shared/support/fxsupportpch.hpp @@ -17,9 +17,9 @@ Abstract: #define __FX_SUPPORT_PCH_HPP__ #if FX_CORE_MODE == FX_CORE_USER_MODE -#include "um\FxSupportPchUM.hpp" +#include "um/fxsupportpchum.hpp" #elif FX_CORE_MODE == FX_CORE_KERNEL_MODE -#include "km\FxSupportPchKM.hpp" +#include "km/fxsupportpchkm.hpp" #endif #endif // __FX_SUPPORT_PCH_HPP__ diff --git a/sdk/lib/drivers/wdf/shared/support/fxtelemetry.cpp b/sdk/lib/drivers/wdf/shared/support/fxtelemetry.cpp index 09ff414d9e6..8d91c29f6e5 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxtelemetry.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxtelemetry.cpp @@ -32,13 +32,13 @@ Notes: #include "fxldr.h" #include #else -#include "DriverFrameworks-UserMode-UmEvents.h" -#include "FxldrUm.h" +#include "driverframeworks-usermode-umevents.h" +#include "fxldrum.h" #endif extern "C" { #if defined(EVENT_TRACING) -#include "FxTelemetry.tmh" +#include "fxtelemetry.tmh" #endif } diff --git a/sdk/lib/drivers/wdf/shared/support/fxtransactionedlist.cpp b/sdk/lib/drivers/wdf/shared/support/fxtransactionedlist.cpp index e970f1a0c15..bd4becd58b1 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxtransactionedlist.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxtransactionedlist.cpp @@ -24,7 +24,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" FxTransactionedList::FxTransactionedList() { diff --git a/sdk/lib/drivers/wdf/shared/support/fxwaitlock.cpp b/sdk/lib/drivers/wdf/shared/support/fxwaitlock.cpp index 12e01fde79e..ef6765a33aa 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxwaitlock.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxwaitlock.cpp @@ -18,12 +18,12 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" #if defined(EVENT_TRACING) // Tracing support extern "C" { -#include "FxWaitLock.tmh" +#include "fxwaitlock.tmh" } #endif diff --git a/sdk/lib/drivers/wdf/shared/support/fxwaitlockapi.cpp b/sdk/lib/drivers/wdf/shared/support/fxwaitlockapi.cpp index c02e923c119..0f919e6f01c 100644 --- a/sdk/lib/drivers/wdf/shared/support/fxwaitlockapi.cpp +++ b/sdk/lib/drivers/wdf/shared/support/fxwaitlockapi.cpp @@ -22,7 +22,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" // extern the entire file extern "C" { @@ -32,6 +32,7 @@ _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfWaitLockCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -97,6 +98,7 @@ __drv_when(Timeout != 0 && *Timeout == 0, __drv_maxIRQL(DISPATCH_LEVEL)) __drv_when(Timeout != 0 && *Timeout != 0, __drv_maxIRQL(PASSIVE_LEVEL)) NTSTATUS WDFAPI +STDCALL WDFEXPORT(WdfWaitLockAcquire)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -151,6 +153,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) VOID WDFAPI +STDCALL WDFEXPORT(WdfWaitLockRelease)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/support/km/fxdeviceinterfacekm.cpp b/sdk/lib/drivers/wdf/shared/support/km/fxdeviceinterfacekm.cpp index 0fb95e621b2..0f61d5382a0 100644 --- a/sdk/lib/drivers/wdf/shared/support/km/fxdeviceinterfacekm.cpp +++ b/sdk/lib/drivers/wdf/shared/support/km/fxdeviceinterfacekm.cpp @@ -22,10 +22,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxDeviceInterfaceKM.tmh" +// #include "FxDeviceInterfaceKM.tmh" } FxDeviceInterface::FxDeviceInterface( diff --git a/sdk/lib/drivers/wdf/shared/support/km/fxregkeykm.cpp b/sdk/lib/drivers/wdf/shared/support/km/fxregkeykm.cpp index a6c5e3fa23d..3e576061075 100644 --- a/sdk/lib/drivers/wdf/shared/support/km/fxregkeykm.cpp +++ b/sdk/lib/drivers/wdf/shared/support/km/fxregkeykm.cpp @@ -18,10 +18,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxRegKeyKM.tmh" +// #include "FxRegKeyKM.tmh" } #define AT_PASSIVE() ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL) diff --git a/sdk/lib/drivers/wdf/shared/support/km/fxrequestbufferkm.cpp b/sdk/lib/drivers/wdf/shared/support/km/fxrequestbufferkm.cpp index d2f82410dcc..0d5c675e0f8 100644 --- a/sdk/lib/drivers/wdf/shared/support/km/fxrequestbufferkm.cpp +++ b/sdk/lib/drivers/wdf/shared/support/km/fxrequestbufferkm.cpp @@ -22,10 +22,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "FxRequestBufferKm.tmh" +// #include "FxRequestBufferKm.tmh" } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/support/km/fxresourcecollectionkm.cpp b/sdk/lib/drivers/wdf/shared/support/km/fxresourcecollectionkm.cpp index f74a1519150..6eb703d8a28 100644 --- a/sdk/lib/drivers/wdf/shared/support/km/fxresourcecollectionkm.cpp +++ b/sdk/lib/drivers/wdf/shared/support/km/fxresourcecollectionkm.cpp @@ -23,7 +23,7 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" #if defined(EVENT_TRACING) // Tracing support diff --git a/sdk/lib/drivers/wdf/shared/support/km/fxsupportpchkm.hpp b/sdk/lib/drivers/wdf/shared/support/km/fxsupportpchkm.hpp index 67b2a6097c9..730cfec8021 100644 --- a/sdk/lib/drivers/wdf/shared/support/km/fxsupportpchkm.hpp +++ b/sdk/lib/drivers/wdf/shared/support/km/fxsupportpchkm.hpp @@ -29,13 +29,13 @@ extern "C" { #include -#include "FxCollection.hpp" -#include "StringUtil.hpp" -#include "FxString.hpp" -#include "FxDeviceText.hpp" -#include "FxWaitLock.hpp" +#include "fxcollection.hpp" +#include "stringutil.hpp" +#include "fxstring.hpp" +#include "fxdevicetext.hpp" +#include "fxwaitlock.hpp" -#include -#include +#include +#include #endif // __FX_SUPPORT_PCH_KM_HPP__ diff --git a/sdk/lib/drivers/wdf/shared/support/stringutil.cpp b/sdk/lib/drivers/wdf/shared/support/stringutil.cpp index 35ec4f21fad..2e844846b06 100644 --- a/sdk/lib/drivers/wdf/shared/support/stringutil.cpp +++ b/sdk/lib/drivers/wdf/shared/support/stringutil.cpp @@ -22,10 +22,10 @@ Revision History: --*/ -#include "FxSupportPch.hpp" +#include "fxsupportpch.hpp" extern "C" { -#include "StringUtil.tmh" +// #include "StringUtil.tmh" } size_t diff --git a/sdk/lib/drivers/wdf/shared/targets/fxtargetsshared.hpp b/sdk/lib/drivers/wdf/shared/targets/fxtargetsshared.hpp index 2f1ab4dbcdf..6b58f73a051 100644 --- a/sdk/lib/drivers/wdf/shared/targets/fxtargetsshared.hpp +++ b/sdk/lib/drivers/wdf/shared/targets/fxtargetsshared.hpp @@ -36,15 +36,15 @@ extern "C" { #include "mx.h" } -#include "FxMin.hpp" +#include "fxmin.hpp" #include "wdfmemory.h" #include "wdfrequest.h" #include "wdfdevice.h" -#include "wdfWmi.h" -#include "wdfChildList.h" +#include "wdfwmi.h" +#include "wdfchildlist.h" #include "wdfpdo.h" #include "wdffdo.h" #include "wdfiotarget.h" @@ -53,26 +53,26 @@ extern "C" { #include "wdfio.h" #include "wdfqueryinterface.h" -#include "FxIrpQueue.hpp" -#include "FxCallback.hpp" +#include "fxirpqueue.hpp" +#include "fxcallback.hpp" #if (FX_CORE_MODE == FX_CORE_USER_MODE) -#include "FxIrpUm.hpp" -#else if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE)) -#include "FxIrpKm.hpp" +#include "fxirpum.hpp" +#elif ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE)) +#include "fxirpkm.hpp" #endif -#include "FxTransactionedList.hpp" +#include "fxtransactionedlist.hpp" -#include "FxCollection.hpp" -#include "FxDeviceInitShared.hpp" -#include "FxDeviceToMxInterface.hpp" -#include "FxRequestContext.hpp" -#include "FxRequestContextTypes.h" -#include "FxRequestBase.hpp" -#include "FxRequestBuffer.hpp" -#include "IfxMemory.hpp" -#include "FxIoTarget.hpp" -#include "FxIoTargetRemote.hpp" -#include "FxIoTargetSelf.hpp" +#include "fxcollection.hpp" +#include "fxdeviceinitshared.hpp" +#include "fxdevicetomxinterface.hpp" +#include "fxrequestcontext.hpp" +#include "fxrequestcontexttypes.h" +#include "fxrequestbase.hpp" +#include "fxrequestbuffer.hpp" +#include "ifxmemory.hpp" +#include "fxiotarget.hpp" +#include "fxiotargetremote.hpp" +#include "fxiotargetself.hpp" diff --git a/sdk/lib/drivers/wdf/shared/targets/general/fxiotarget.cpp b/sdk/lib/drivers/wdf/shared/targets/general/fxiotarget.cpp index 57867b55d25..12066b6891f 100644 --- a/sdk/lib/drivers/wdf/shared/targets/general/fxiotarget.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/general/fxiotarget.cpp @@ -21,7 +21,7 @@ Revision History: --*/ -#include "..\FxTargetsShared.hpp" +#include "../fxtargetsshared.hpp" extern "C" { #if defined(EVENT_TRACING) @@ -308,12 +308,10 @@ FxIoTarget::GotoStartState( __in BOOLEAN Lock ) { - FxRequestBase* pRequest; NTSTATUS status; KIRQL irql; irql = PASSIVE_LEVEL; - pRequest = NULL; ADDREF(START_TAG); @@ -1110,7 +1108,7 @@ FxIoTarget::QueryInterface( *Params->Object = (FxIoTarget*) this; break; default: - return __super::QueryInterface(Params); + return FxNonPagedObject::QueryInterface(Params); // __super call } return STATUS_SUCCESS; diff --git a/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetapi.cpp b/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetapi.cpp index 625c16a1890..50304821f3d 100644 --- a/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetapi.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetapi.cpp @@ -20,10 +20,10 @@ Revision History: --*/ -#include "..\FxTargetsShared.hpp" +#include "../fxtargetsshared.hpp" extern "C" { -#include "FxIoTargetAPI.tmh" +// #include "FxIoTargetAPI.tmh" } // @@ -34,6 +34,7 @@ extern "C" { _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetStart)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -69,6 +70,7 @@ Return Value: __drv_when(Action == 3, __drv_maxIRQL(DISPATCH_LEVEL)) __drv_when(Action == 0 || Action == 1 || Action == 2, __drv_maxIRQL(PASSIVE_LEVEL)) VOID +STDCALL WDFEXPORT(WdfIoTargetStop)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -128,6 +130,7 @@ Return Value: __drv_when(Action == 2, __drv_maxIRQL(DISPATCH_LEVEL)) __drv_when(Action == 0 || Action == 1, __drv_maxIRQL(PASSIVE_LEVEL)) VOID +STDCALL WDFEXPORT(WdfIoTargetPurge)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -185,6 +188,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) WDF_IO_TARGET_STATE +STDCALL WDFEXPORT(WdfIoTargetGetState)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -364,6 +368,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetCreate)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -437,6 +442,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetOpen)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -543,6 +549,7 @@ Return Value: __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoTargetCloseForQueryRemove)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -591,6 +598,7 @@ Return Value: __drv_maxIRQL(PASSIVE_LEVEL) VOID +STDCALL WDFEXPORT(WdfIoTargetClose)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -636,6 +644,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) WDFDEVICE +STDCALL WDFEXPORT(WdfIoTargetGetDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -943,6 +952,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendReadSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -975,6 +985,7 @@ WDFEXPORT(WdfIoTargetSendReadSynchronously)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForRead)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1005,6 +1016,7 @@ WDFEXPORT(WdfIoTargetFormatRequestForRead)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendWriteSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1037,6 +1049,7 @@ WDFEXPORT(WdfIoTargetSendWriteSynchronously)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForWrite)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1386,6 +1399,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendIoctlSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1423,6 +1437,7 @@ WDFEXPORT(WdfIoTargetSendIoctlSynchronously)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForIoctl)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1458,6 +1473,7 @@ WDFEXPORT(WdfIoTargetFormatRequestForIoctl)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendInternalIoctlSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1495,6 +1511,7 @@ WDFEXPORT(WdfIoTargetSendInternalIoctlSynchronously)( _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctl)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1530,6 +1547,7 @@ WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctl)( _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSendInternalIoctlOthersSynchronously)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1708,6 +1726,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctlOthers)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1847,6 +1866,7 @@ Return Value: _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetSelfAssignDefaultIoQueue)( _In_ PWDF_DRIVER_GLOBALS DriverGlobals, @@ -1964,6 +1984,7 @@ Returns: __drv_maxIRQL(DISPATCH_LEVEL) HANDLE +STDCALL WDFEXPORT(WdfIoTargetWdmGetTargetFileHandle)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetremote.cpp b/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetremote.cpp index 5a125f852ed..a028dbc9893 100644 --- a/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetremote.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetremote.cpp @@ -18,10 +18,10 @@ Revision History: --*/ -#include "..\FxTargetsShared.hpp" +#include "../fxtargetsshared.hpp" extern "C" { -#include "FxIoTargetRemote.tmh" +// #include "FxIoTargetRemote.tmh" } #include @@ -55,7 +55,7 @@ FxIoTargetRemote::FxIoTargetRemote( #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) m_TargetNotifyHandle = NULL; -#else (FX_CORE_MODE == FX_CORE_USER_MODE) +#elif (FX_CORE_MODE == FX_CORE_USER_MODE) m_TargetNotifyHandle = WUDF_TARGET_CONTEXT_INVALID; m_pIoDispatcher = NULL; @@ -173,7 +173,7 @@ FxIoTargetRemote::InitRemote( // // do the base class mode-specific initialization // - status = __super::InitModeSpecific(Device); + status = FxIoTarget::InitModeSpecific(Device); // __super call if (!NT_SUCCESS(status)) { return status; } @@ -757,7 +757,7 @@ FxIoTargetRemote::ClearTargetPointers( // canceled or completing. When we receive either of those notifications, // m_TargetNotifyHandle will be freed then. // - __super::ClearTargetPointers(); + FxIoTarget::ClearTargetPointers(); // __super call } VOID diff --git a/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetself.cpp b/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetself.cpp index a74b10c50a2..4f7d6fc34bc 100644 --- a/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetself.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/general/fxiotargetself.cpp @@ -24,7 +24,7 @@ Revision History: --*/ -#include "..\FxTargetsShared.hpp" +#include "../fxtargetsshared.hpp" extern "C" { #if defined(EVENT_TRACING) diff --git a/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetapikm.cpp b/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetapikm.cpp index d25d41eeac4..3c07d9f62d3 100644 --- a/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetapikm.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetapikm.cpp @@ -20,10 +20,10 @@ Revision History: --*/ -#include "..\..\FxTargetsShared.hpp" +#include "../../fxtargetsshared.hpp" extern "C" { -#include "FxIoTargetAPIKm.tmh" +// #include "FxIoTargetAPIKm.tmh" } // @@ -33,6 +33,7 @@ extern "C" { __drv_maxIRQL(DISPATCH_LEVEL) PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfIoTargetWdmGetTargetDeviceObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -76,6 +77,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) PDEVICE_OBJECT +STDCALL WDFEXPORT(WdfIoTargetWdmGetTargetPhysicalDevice)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -121,6 +123,7 @@ Return Value: __drv_maxIRQL(DISPATCH_LEVEL) PFILE_OBJECT +STDCALL WDFEXPORT(WdfIoTargetWdmGetTargetFileObject)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -165,6 +168,7 @@ Return Value: __drv_maxIRQL(PASSIVE_LEVEL) _Must_inspect_result_ NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetQueryForInterface)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -242,6 +246,7 @@ Return Value: _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetQueryTargetProperty)( __in PWDF_DRIVER_GLOBALS DriverGlobals, @@ -254,7 +259,7 @@ WDFEXPORT(WdfIoTargetQueryTargetProperty)( __drv_when(BufferLength != 0, __out_bcount_part_opt(BufferLength, *ResultLength)) __drv_when(BufferLength == 0, __out_opt) PVOID PropertyBuffer, - __deref_out_range(<=,BufferLength) + __deref_out_range(<=,BufferLength) PULONG ResultLength ) /*++ @@ -333,6 +338,7 @@ _Must_inspect_result_ __drv_maxIRQL(PASSIVE_LEVEL) WDFAPI NTSTATUS +STDCALL WDFEXPORT(WdfIoTargetAllocAndQueryTargetProperty)( __in PWDF_DRIVER_GLOBALS DriverGlobals, diff --git a/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetkm.cpp b/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetkm.cpp index ca2d075c9a2..c287c55bad1 100644 --- a/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetkm.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetkm.cpp @@ -21,7 +21,7 @@ Revision History: --*/ -#include "..\..\FxTargetsShared.hpp" +#include "../../fxtargetsshared.hpp" extern "C" { #if defined(EVENT_TRACING) diff --git a/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetremotekm.cpp b/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetremotekm.cpp index ce88c1a1004..63f743c380a 100644 --- a/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetremotekm.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetremotekm.cpp @@ -18,10 +18,10 @@ Revision History: --*/ -#include "..\..\FxTargetsShared.hpp" +#include "../../fxtargetsshared.hpp" extern "C" { -#include "FxIoTargetRemoteKm.tmh" +// #include "FxIoTargetRemoteKm.tmh" } #include @@ -48,7 +48,7 @@ FxIoTargetRemote::_PlugPlayNotification( // If that is the case, we need to be able to return and deref the object until // we are done. // - pThis->ADDREF(_PlugPlayNotification); + pThis->ADDREF((PVOID)_PlugPlayNotification); pFxDriverGlobals = pThis->GetDriverGlobals(); @@ -133,7 +133,7 @@ FxIoTargetRemote::_PlugPlayNotification( } } - pThis->RELEASE(_PlugPlayNotification); + pThis->RELEASE((PVOID)_PlugPlayNotification); return status; } diff --git a/sdk/lib/drivers/wdf/shared/targets/usb/fxusbdevice.cpp b/sdk/lib/drivers/wdf/shared/targets/usb/fxusbdevice.cpp index 01c1cc9ace0..b436a305867 100644 --- a/sdk/lib/drivers/wdf/shared/targets/usb/fxusbdevice.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/usb/fxusbdevice.cpp @@ -108,7 +108,7 @@ FxUsbDeviceControlContext::CopyParameters( m_CompletionParams.IoStatus.Information = m_UmUrb.UmUrbControlTransfer.TransferBufferLength; m_UsbParameters.Parameters.DeviceControlTransfer.Length = m_UmUrb.UmUrbControlTransfer.TransferBufferLength; #endif - __super::CopyParameters(Request); + FxUsbRequestContext::CopyParameters(Request); // __super call } VOID @@ -131,7 +131,7 @@ FxUsbDeviceControlContext::ReleaseAndRestore( m_PartialMdl = NULL; } - __super::ReleaseAndRestore(Request); + FxUsbRequestContext::ReleaseAndRestore(Request); // __super call } USBD_STATUS @@ -262,7 +262,7 @@ FxUsbDeviceStringContext::CopyParameters( } } - __super::CopyParameters(Request); + FxUsbRequestContext::CopyParameters(Request); // __super call } VOID @@ -365,7 +365,7 @@ FxUsbUrb::Dispose( m_pBuffer = NULL; m_USBDHandle = NULL; - return __super::Dispose(); + return FxMemoryBufferPreallocated::Dispose(); // __super call } FxUsbDevice::FxUsbDevice( @@ -429,7 +429,7 @@ FxUsbDevice::Dispose( } #endif - return __super::Dispose(); + return FxIoTarget::Dispose(); // __super call } FxUsbDevice::~FxUsbDevice() @@ -2114,7 +2114,7 @@ FxUsbDevice::CancelSentIo( } } } - __super::CancelSentIo(); + FxIoTarget::CancelSentIo(); // __super call } __checkReturn diff --git a/sdk/lib/drivers/wdf/shared/targets/usb/fxusbpipe.cpp b/sdk/lib/drivers/wdf/shared/targets/usb/fxusbpipe.cpp index ab20efe40b7..de5072b04fa 100644 --- a/sdk/lib/drivers/wdf/shared/targets/usb/fxusbpipe.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/usb/fxusbpipe.cpp @@ -876,7 +876,7 @@ FxUsbPipeTransferContext::ReleaseAndRestore( m_PartialMdl = NULL; } #endif - __super::ReleaseAndRestore(Request); + FxUsbRequestContext::ReleaseAndRestore(Request); // __super call } VOID @@ -896,7 +896,7 @@ FxUsbPipeTransferContext::CopyParameters( Parameters.PipeWrite.Length)); m_UsbParameters.Parameters.PipeRead.Length = GetUrbTransferLength(); - __super::CopyParameters(Request); + FxUsbRequestContext::CopyParameters(Request); // __super call } VOID @@ -957,7 +957,7 @@ FxUsbUrbContext::ReleaseAndRestore( ) { m_pUrb = NULL; - __super::ReleaseAndRestore(Request); + FxUsbRequestContext::ReleaseAndRestore(Request); // __super call } @@ -1106,7 +1106,7 @@ FxUsbPipe::Dispose() // // Call base class: callbacks, terminates I/Os, etc. // - callCleanup = __super::Dispose(); + callCleanup = FxIoTarget::Dispose(); // __super call // // Don't need the reader anymore. The reader is deleted after calling the @@ -1245,7 +1245,7 @@ FxUsbPipe::GotoStopState( Action = WdfIoTargetCancelSentIo; } - __super::GotoStopState(Action, SentRequestListHead, Wait, FALSE); + FxIoTarget::GotoStopState(Action, SentRequestListHead, Wait, FALSE); // __super call if (m_Reader != NULL) { // @@ -1323,7 +1323,7 @@ FxUsbPipe::GotoPurgeState( Action = WdfIoTargetPurgeIoAndWait; } - __super::GotoPurgeState(Action, + FxIoTarget::GotoPurgeState(Action, // __super call PendedRequestListHead, SentRequestListHead, Wait, @@ -1395,7 +1395,7 @@ FxUsbPipe::GotoRemoveState( } } - __super::GotoRemoveState(NewState, + FxIoTarget::GotoRemoveState(NewState, // __super call PendedRequestListHead, SentRequestListHead, FALSE, @@ -1455,7 +1455,7 @@ FxUsbPipe::WaitForSentIoToComplete( // // Finally, let the parent class wait for all I/O to complete // - __super::WaitForSentIoToComplete(); + FxIoTarget::WaitForSentIoToComplete(); // __super call } _Must_inspect_result_ diff --git a/sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbdevicekm.cpp b/sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbdevicekm.cpp index 1fa99641b45..9776a3f8135 100644 --- a/sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbdevicekm.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbdevicekm.cpp @@ -698,7 +698,7 @@ FxUsbDeviceControlContext::StoreAndReferenceMemory( m_Urb->Hdr.Function = URB_FUNCTION_CONTROL_TRANSFER; m_Urb->Hdr.Length = sizeof(*m_Urb); - __super::StoreAndReferenceMemory(Buffer); + FxUsbRequestContext::StoreAndReferenceMemory(Buffer); // __super call // // Set the values using what is stored in the buffer diff --git a/sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbpipekm.cpp b/sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbpipekm.cpp index acae3b57e4e..7e10a5d59fc 100644 --- a/sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbpipekm.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbpipekm.cpp @@ -32,7 +32,7 @@ Return Value: m_Urb->Hdr.Function = URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER; m_Urb->Hdr.Length = sizeof(*m_Urb); - __super::StoreAndReferenceMemory(Buffer); + FxUsbRequestContext::StoreAndReferenceMemory(Buffer); // __super call Buffer->AssignValues(&m_Urb->TransferBuffer, &m_Urb->TransferBufferMDL, diff --git a/sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbdeviceum.cpp b/sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbdeviceum.cpp index e339fd06ef2..d364f78ed95 100644 --- a/sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbdeviceum.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbdeviceum.cpp @@ -562,7 +562,7 @@ FxUsbDeviceControlContext::StoreAndReferenceMemory( { SetUsbType(WdfUsbRequestTypeDeviceControlTransfer); - __super::StoreAndReferenceMemory(Buffer); + FxUsbRequestContext::StoreAndReferenceMemory(Buffer); // __super call // // Convert WDF_USB_CONTROL_SETUP_PACKET to WINUSB_SETUP_PACKET diff --git a/sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbpipeum.cpp b/sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbpipeum.cpp index c7f420dcfe3..af06866376f 100644 --- a/sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbpipeum.cpp +++ b/sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbpipeum.cpp @@ -51,7 +51,7 @@ Return Value: m_UmUrb.UmUrbHeader.Function = UMURB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER; m_UmUrb.UmUrbHeader.Length = sizeof(_UMURB_BULK_OR_INTERRUPT_TRANSFER); - __super::StoreAndReferenceMemory(Buffer); + FxUsbRequestContext::StoreAndReferenceMemory(Buffer); // __super call Buffer->AssignValues(&m_UmUrb.UmUrbBulkOrInterruptTransfer.TransferBuffer, NULL, diff --git a/sdk/lib/drivers/wdf/umdf/fxlib/version/framework.cpp b/sdk/lib/drivers/wdf/umdf/fxlib/version/framework.cpp index 34e785693f3..e07d9a52d54 100644 --- a/sdk/lib/drivers/wdf/umdf/fxlib/version/framework.cpp +++ b/sdk/lib/drivers/wdf/umdf/fxlib/version/framework.cpp @@ -30,9 +30,8 @@ extern "C" { extern WDF_LIBRARY_INFO WdfLibraryInfo; #if !(NO_UMDF_VERSION_EXPORT) -__declspec(dllexport) - -__declspec(selectany) +DECLSPEC_EXPORT +DECLSPEC_SELECTANY UMDF_VERSION_DATA Microsoft_WDF_UMDF_Version = {__WUDF_MAJOR_VERSION, diff --git a/sdk/lib/drivers/wdf/umdf/fxlib/version/version.cpp b/sdk/lib/drivers/wdf/umdf/fxlib/version/version.cpp index e374ab4f6c0..3c18d3e38d0 100644 --- a/sdk/lib/drivers/wdf/umdf/fxlib/version/version.cpp +++ b/sdk/lib/drivers/wdf/umdf/fxlib/version/version.cpp @@ -35,8 +35,8 @@ extern "C" { #include "mx.h" } #include "fxmin.hpp" -#include "fxldrUm.h" -#include "fxIFR.h" +#include "fxldrum.h" +#include "fxifr.h" #include #include @@ -45,9 +45,9 @@ extern const WDFFUNC *WdfFunctions; extern "C" { -#include "FxDynamics.h" +#include "fxdynamics.h" -#include "..\librarycommon\FxLibraryCommon.h" +#include "..\librarycommon\fxlibrarycommon.h" #define KMDF_DEFAULT_NAME "Wdf" ## \ LITERAL(__WDF_MAJOR_VERSION) ## \ diff --git a/sdk/lib/drivers/wdf/usbspec.h b/sdk/lib/drivers/wdf/usbspec.h new file mode 100644 index 00000000000..c9e7ad20d37 --- /dev/null +++ b/sdk/lib/drivers/wdf/usbspec.h @@ -0,0 +1,14 @@ +/* + * PROJECT: Kernel Mode Device Framework + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Missing headers (usbspec.h) + * COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin@reactos.org) + */ + +#ifndef __USBSPEC_H__ +#define __USBSPEC_H__ + +#include +#include + +#endif diff --git a/sdk/lib/drivers/wdf/wdf01000_reg.inf b/sdk/lib/drivers/wdf/wdf01000_reg.inf new file mode 100644 index 00000000000..152675d4dcb --- /dev/null +++ b/sdk/lib/drivers/wdf/wdf01000_reg.inf @@ -0,0 +1,17 @@ +; Kernel Mode Driver Frameworks (wdf01000.sys) +[AddReg] +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","ErrorControl",0x00010001,0x00000000 +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","Group",0x00000000,"WdfLoadGroup" +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","DisplayName",0x00000000,"Kernel Mode Driver Frameworks service" +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","ImagePath",0x00020000,"system32\drivers\wdf01000.sys" +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","Start",0x00010001,0x00000003 +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","Type",0x00010001,0x00000001 +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Enum","0",0x00000000,"Root\LEGACY_WDF01000\0000" +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Enum","Count",0x00010001,0x00000001 +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Enum","NextInstance",0x00010001,0x00000001 +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Parameters","BuildNumber",0x00010001,0x00001db0 +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Parameters","MajorVersion",0x00010001,0x00000001 +HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Parameters","MinorVersion",0x00010001,0x00000009 +HKLM,"SYSTEM\CurrentControlSet\Control\Wdf\Kmdf\KmdfLibrary\Versions\1","Service",0x00000000,"Wdf01000" +HKLM,"SYSTEM\ControlSet001\Enum\Root\LEGACY_WDF01000","NextInstance",0x00010001,0x00000001 +HKLM,"SYSTEM\ControlSet001\Enum\Root\LEGACY_WDF01000\0000","ActiveService",0x00000000,"Wdf01000" diff --git a/sdk/lib/drivers/wdf/wdfcx.h b/sdk/lib/drivers/wdf/wdfcx.h new file mode 100644 index 00000000000..a5e62d7f234 --- /dev/null +++ b/sdk/lib/drivers/wdf/wdfcx.h @@ -0,0 +1,141 @@ +/* + * PROJECT: Kernel Mode Device Framework + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Missing headers (wdfcx.h) + * COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin@reactos.org) + */ + +#ifndef _WDFCX_H_ +#define _WDFCX_H_ + +typedef BOOLEAN +(STDCALL *PFN_WDFCX_DEVICE_FILE_CREATE) ( + _In_ WDFDEVICE Device, + _In_ WDFREQUEST Request, + _In_opt_ WDFFILEOBJECT FileObject); + +// _WDFCX_FILEOBJECT_CONFIG_V1_17 + +typedef struct _WDFCX_FILEOBJECT_CONFIG { + // + // Size of this structure in bytes + // + ULONG Size; + + // + // Event callback for create requests + // + PFN_WDFCX_DEVICE_FILE_CREATE EvtCxDeviceFileCreate; + + // + // 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; + +} WDFCX_FILEOBJECT_CONFIG, *PWDFCX_FILEOBJECT_CONFIG; + +typedef NTSTATUS +(STDCALL *PFN_WDFCXDEVICE_WDM_IRP_PREPROCESS)( + _In_ WDFDEVICE Device, + _Inout_ PIRP Irp, + _In_ PVOID DispatchContext); + +typedef PWDFCXDEVICE_INIT +(STDCALL *PFN_WDFCXDEVICEINITALLOCATE)( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_ PWDFDEVICE_INIT DeviceInit); + +typedef NTSTATUS +(STDCALL *PFN_WDFCXDEVICEINITASSIGNWDMIRPPREPROCESSCALLBACK) ( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_ PWDFCXDEVICE_INIT CxDeviceInit, + _In_ PFN_WDFCXDEVICE_WDM_IRP_PREPROCESS EvtCxDeviceWdmIrpPreprocess, + _In_ UCHAR MajorFunction, + _When_(NumMinorFunctions > 0, _In_reads_bytes_(NumMinorFunctions)) + _When_(NumMinorFunctions == 0, _In_opt_) + PUCHAR MinorFunctions, + _In_ ULONG NumMinorFunctions); + +typedef VOID +(STDCALL *PFN_WDFCXDEVICEINITSETIOINCALLERCONTEXTCALLBACK)( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_ PWDFCXDEVICE_INIT CxDeviceInit, + _In_ PFN_WDF_IO_IN_CALLER_CONTEXT EvtIoInCallerContext); + +typedef VOID +(STDCALL *PFN_WDFCXDEVICEINITSETREQUESTATTRIBUTES)( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_ PWDFCXDEVICE_INIT CxDeviceInit, + _In_ PWDF_OBJECT_ATTRIBUTES RequestAttributes); + +typedef VOID +(STDCALL *PFN_WDFCXDEVICEINITSETFILEOBJECTCONFIG)( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_ PWDFCXDEVICE_INIT CxDeviceInit, + _In_ PWDFCX_FILEOBJECT_CONFIG CxFileObjectConfig, + _In_opt_ PWDF_OBJECT_ATTRIBUTES FileObjectAttributes); + +typedef VOID +(STDCALL *PFN_WDFCXVERIFIERKEBUGCHECK)( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_opt_ WDFOBJECT Object, + _In_ ULONG BugCheckCode, + _In_ ULONG_PTR BugCheckParameter1, + _In_ ULONG_PTR BugCheckParameter2, + _In_ ULONG_PTR BugCheckParameter3, + _In_ ULONG_PTR BugCheckParameter4); + +typedef WDFIOTARGET +(STDCALL *PFN_WDFDEVICEGETSELFIOTARGET)( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_ WDFDEVICE Device); + +typedef VOID +(STDCALL *PFN_WDFDEVICEINITALLOWSELFIOTARGET)( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_ PWDFDEVICE_INIT DeviceInit); + +typedef NTSTATUS +(STDCALL *PFN_WDFIOTARGETSELFASSIGNDEFAULTIOQUEUE)( + _In_ PWDF_DRIVER_GLOBALS DriverGlobals, + _In_ WDFIOTARGET IoTarget, + _In_ WDFQUEUE Queue); + +// some other random stuff + +typedef PVOID PFN_WDF_CLASS_EXTENSIONIN_BIND; +typedef PVOID PFN_WDF_CLASS_EXTENSIONIN_UNBIND; +typedef PVOID PFN_WDF_CLASS_EXPORT; +typedef PVOID PFN_WDF_CLASS_LIBRARY_INITIALIZE; +typedef PVOID PFN_WDF_CLASS_LIBRARY_DEINITIALIZE; +typedef PVOID PFN_WDF_CLASS_LIBRARY_BIND_CLIENT; +typedef PVOID PFN_WDF_CLASS_LIBRARY_UNBIND_CLIENT; +typedef PVOID PFN_WDF_CLIENT_BIND_CLASS; +typedef PVOID PFN_WDF_CLIENT_UNBIND_CLASS; + +#endif // _WDFCX_H_ diff --git a/sdk/lib/drivers/wdf/wdfldr.h b/sdk/lib/drivers/wdf/wdfldr.h new file mode 100644 index 00000000000..b404451e7cd --- /dev/null +++ b/sdk/lib/drivers/wdf/wdfldr.h @@ -0,0 +1,38 @@ +/* + * PROJECT: Kernel Mode Device Framework + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Missing headers (wdfldr.h) + * COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin@reactos.org) + */ + +// likely to be removed when the proper wdfldr.sys is ready + +#ifndef _WDFLDR_H_ +#define _WDFLDR_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _LIBRARY_MODULE* PLIBRARY_MODULE; +typedef struct _WDF_LIBRARY_INFO* PWDF_LIBRARY_INFO; + +typedef ULONG WDF_MAJOR_VERSION; +typedef ULONG WDF_MINOR_VERSION; +typedef ULONG WDF_BUILD_NUMBER; +typedef PVOID WDF_COMPONENT_GLOBALS, *PWDF_COMPONENT_GLOBALS; + +typedef struct _WDF_INTERFACE_HEADER { + const GUID *InterfaceType; + ULONG InterfaceSize; +} WDF_INTERFACE_HEADER, *PWDF_INTERFACE_HEADER; + +typedef struct _WDF_BIND_INFO *PWDF_BIND_INFO; + +typedef NTSTATUS (STDCALL *PWDF_LDR_DIAGNOSTICS_VALUE_BY_NAME_AS_ULONG)(PUNICODE_STRING, PULONG); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _WDFLDR_H_