huwcampbell.com
Reactos
[WDF] Fix KMDF so it can compile with ReactOS SDK Not all files are included, but these are necessary to compile cdrom driver. So far it can only be statically linked with drivers, a proper implementation requires wdfldr helper driver
+4045
-2385
+1
sdk/lib/drivers/CMakeLists.txt
+1
sdk/lib/drivers/CMakeLists.txt
+217
sdk/lib/drivers/wdf/CMakeLists.txt
+217
sdk/lib/drivers/wdf/CMakeLists.txt
···
1
+
2
+
remove_definitions(-D_WIN32_WINNT=0x502)
3
+
4
+
list(APPEND SOURCE_SHARED
5
+
shared/core/fxcxdeviceinit.cpp
6
+
# shared/core/fxcxdeviceinitapi.cpp
7
+
shared/core/fxdevice.cpp
8
+
shared/core/fxdeviceapi.cpp
9
+
shared/core/fxdevicebase.cpp
10
+
shared/core/fxdevicecontrolapi.cpp
11
+
shared/core/fxdeviceinit.cpp
12
+
shared/core/fxdeviceinitapi.cpp
13
+
shared/core/fxdisposelist.cpp
14
+
shared/core/fxdriver.cpp
15
+
shared/core/fxdriverapi.cpp
16
+
shared/core/fxfileobject.cpp
17
+
shared/core/fxfileobjectapi.cpp
18
+
shared/core/fxirpqueue.cpp
19
+
# shared/core/fxlock.cpp
20
+
shared/core/fxlookasidelist.cpp
21
+
shared/core/fxlookasidelistapi.cpp
22
+
shared/core/fxmemorybuffer.cpp
23
+
shared/core/fxmemorybufferapi.cpp
24
+
shared/core/fxmemorybufferfromlookaside.cpp
25
+
shared/core/fxmemorybufferfrompool.cpp
26
+
shared/core/fxmemorybufferpreallocated.cpp
27
+
shared/core/fxmemorybufferpreallocatedapi.cpp
28
+
shared/core/fxmemoryobject.cpp
29
+
shared/core/fxpagedlookasidelist.cpp
30
+
shared/core/fxrequest.cpp
31
+
shared/core/fxrequestapi.cpp
32
+
shared/core/fxrequestbase.cpp
33
+
shared/core/fxrequestcontext.cpp
34
+
shared/core/fxrequestmemory.cpp
35
+
shared/core/fxrequestoutputbuffer.cpp
36
+
shared/core/fxrequestsystembuffer.cpp
37
+
shared/core/fxsyncrequest.cpp
38
+
shared/core/fxsystemworkitem.cpp
39
+
shared/core/fxtimer.cpp
40
+
shared/core/fxtimerapi.cpp
41
+
shared/core/fxworkitem.cpp
42
+
shared/core/fxworkitemapi.cpp
43
+
# shared/core/verifierapi.cpp
44
+
shared/irphandlers/default/fxdefaultirphandler.cpp
45
+
shared/irphandlers/general/fxpkggeneral.cpp
46
+
shared/irphandlers/io/fxioqueue.cpp
47
+
shared/irphandlers/io/fxioqueueapi.cpp
48
+
shared/irphandlers/io/fxpkgio.cpp
49
+
shared/irphandlers/package/fxpackage.cpp
50
+
# shared/irphandlers/pnp/devicepwrreqstatemachine.cpp
51
+
shared/irphandlers/pnp/eventqueue.cpp
52
+
shared/irphandlers/pnp/fdopower.cpp
53
+
# shared/irphandlers/pnp/fxinterruptapi.cpp
54
+
shared/irphandlers/pnp/fxpkgfdo.cpp
55
+
shared/irphandlers/pnp/fxpkgpdo.cpp
56
+
shared/irphandlers/pnp/fxpkgpnp.cpp
57
+
shared/irphandlers/pnp/interruptobject.cpp
58
+
shared/irphandlers/pnp/notpowerpolicyownerstatemachine.cpp
59
+
shared/irphandlers/pnp/pdopower.cpp
60
+
shared/irphandlers/pnp/pnpstatemachine.cpp
61
+
shared/irphandlers/pnp/poweridlestatemachine.cpp
62
+
shared/irphandlers/pnp/powerpolicystatemachine.cpp
63
+
shared/irphandlers/pnp/powerstatemachine.cpp
64
+
shared/irphandlers/pnp/poxinterface.cpp # stubs
65
+
shared/irphandlers/pnp/selfmanagediostatemachine.cpp
66
+
shared/irphandlers/pnp/wakeinterruptstatemachine.cpp
67
+
shared/object/dbgtrace.cpp
68
+
shared/object/fxobject.cpp
69
+
shared/object/fxobjectapi.cpp
70
+
shared/object/fxobjectstatemachine.cpp
71
+
shared/object/fxtagtracker.cpp
72
+
shared/object/fxuserobject.cpp
73
+
shared/object/fxuserobjectapi.cpp
74
+
shared/object/fxvalidatefunctions.cpp
75
+
shared/object/fxverifierbugcheck.cpp
76
+
shared/object/fxverifierlock.cpp
77
+
shared/object/globals.cpp
78
+
shared/object/handleapi.cpp
79
+
shared/object/wdfpool.cpp
80
+
shared/support/fxcollection.cpp
81
+
shared/support/fxcollectionapi.cpp
82
+
# shared/support/fxdeviceinterface.cpp
83
+
shared/support/fxdeviceinterfaceapi.cpp
84
+
shared/support/fxdevicetext.cpp
85
+
shared/support/fxregistryapi.cpp
86
+
shared/support/fxregkey.cpp
87
+
shared/support/fxrequestbuffer.cpp
88
+
# shared/support/fxresourceapi.cpp
89
+
shared/support/fxresourcecollection.cpp
90
+
shared/support/fxspinlock.cpp
91
+
shared/support/fxspinlockapi.cpp
92
+
shared/support/fxstring.cpp
93
+
shared/support/fxstringapi.cpp
94
+
# shared/support/fxtelemetry.cpp
95
+
shared/support/fxtransactionedlist.cpp
96
+
shared/support/fxwaitlock.cpp
97
+
shared/support/fxwaitlockapi.cpp
98
+
shared/support/stringutil.cpp
99
+
shared/targets/general/fxiotarget.cpp
100
+
shared/targets/general/fxiotargetapi.cpp
101
+
shared/targets/general/fxiotargetremote.cpp
102
+
shared/targets/general/fxiotargetself.cpp
103
+
# shared/targets/usb/fxusbdevice.cpp
104
+
# shared/targets/usb/fxusbdeviceapi.cpp
105
+
# shared/targets/usb/fxusbinterface.cpp
106
+
# shared/targets/usb/fxusbinterfaceapi.cpp
107
+
# shared/targets/usb/fxusbpipe.cpp
108
+
# shared/targets/usb/fxusbpipeapi.cpp
109
+
# shared/targets/usb/usbutil.cpp
110
+
)
111
+
112
+
list(APPEND SOURCE_KM
113
+
kmdf/src/core/fxbugcheckcallback.cpp
114
+
kmdf/src/core/fxchildlist.cpp
115
+
kmdf/src/core/fxchildlistapi.cpp
116
+
kmdf/src/core/fxdevicefdoapi.cpp
117
+
kmdf/src/core/fxdevicepdoapi.cpp
118
+
kmdf/src/core/fxdpc.cpp
119
+
kmdf/src/core/fxdpcapi.cpp
120
+
kmdf/src/core/fxsystemthread.cpp
121
+
# kmdf/src/core/tracing.cpp
122
+
# kmdf/src/dma/base/fxcommonbuffer.cpp # requires DMA stuff
123
+
# kmdf/src/dma/base/fxcommonbufferapi.cpp # requires DMA stuff
124
+
# kmdf/src/dma/base/fxdmaenabler.cpp
125
+
# kmdf/src/dma/base/fxdmaenablerapi.cpp
126
+
# kmdf/src/dma/base/fxdmatransaction.cpp
127
+
# kmdf/src/dma/base/fxdmatransactionapi.cpp
128
+
# kmdf/src/dynamic/version/version.cpp
129
+
kmdf/src/fxtosharedinterface/fxobject/fxobjectinfokm.cpp
130
+
# kmdf/src/irphandlers/wmi/fxwmiapi.cpp
131
+
# kmdf/src/irphandlers/wmi/fxwmiinstance.cpp
132
+
# kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp
133
+
# kmdf/src/irphandlers/wmi/fxwmiprovider.cpp
134
+
# kmdf/src/librarycommon/fxlibrarycommon.cpp
135
+
kmdf/src/support/fxqueryinterface.cpp
136
+
kmdf/src/support/fxqueryinterfaceapi.cpp
137
+
kmdf/src/support/fxrelateddevice.cpp
138
+
kmdf/src/support/fxrelateddevicelist.cpp
139
+
kmdf/src/support/probeandlock.c
140
+
shared/core/km/fxdeviceapikm.cpp
141
+
shared/core/km/fxdevicebasekm.cpp
142
+
shared/core/km/fxdeviceinitkm.cpp
143
+
shared/core/km/fxdevicekm.cpp
144
+
shared/core/km/fxdriverapikm.cpp
145
+
shared/core/km/fxdriverkm.cpp
146
+
shared/core/km/fxfileobjectapikm.cpp
147
+
shared/core/km/fxfileobjectkm.cpp
148
+
shared/core/km/fxnpagedlookasidelistkm.cpp
149
+
shared/core/km/fxrequestkm.cpp
150
+
shared/core/km/fxrequestsystembufferkm.cpp
151
+
shared/irphandlers/io/km/fxioqueuekm.cpp
152
+
shared/irphandlers/pnp/km/eventqueuekm.cpp
153
+
shared/irphandlers/pnp/km/fxpkgfdokm.cpp
154
+
shared/irphandlers/pnp/km/fxpkgpdokm.cpp
155
+
shared/irphandlers/pnp/km/fxpkgpnpkm.cpp
156
+
shared/irphandlers/pnp/km/interruptobjectkm.cpp
157
+
shared/irphandlers/pnp/km/pnpstatemachinekm.cpp
158
+
shared/irphandlers/pnp/km/powerpolicystatemachinekm.cpp
159
+
shared/irphandlers/pnp/km/powerstatemachinekm.cpp # stubs
160
+
# shared/irphandlers/pnp/km/poxinterfacekm.cpp
161
+
shared/irphandlers/pnp/km/supportkm.cpp
162
+
shared/object/km/fxobjectkm.cpp
163
+
shared/object/km/globalskm.cpp
164
+
shared/object/km/wdfpoolkm.cpp
165
+
shared/primitives/km/mxgeneralkm.cpp
166
+
shared/support/km/fxdeviceinterfacekm.cpp
167
+
shared/support/km/fxregkeykm.cpp
168
+
shared/support/km/fxrequestbufferkm.cpp
169
+
shared/support/km/fxresourcecollectionkm.cpp
170
+
# shared/support/km/fxtelemetrykm.cpp
171
+
shared/targets/general/fxiotarget.cpp
172
+
shared/targets/general/fxiotargetapi.cpp
173
+
shared/targets/general/fxiotargetremote.cpp
174
+
shared/targets/general/fxiotargetself.cpp
175
+
shared/targets/general/km/fxiotargetapikm.cpp
176
+
shared/targets/general/km/fxiotargetkm.cpp
177
+
shared/targets/general/km/fxiotargetremotekm.cpp
178
+
reactos_special.cpp
179
+
)
180
+
181
+
# add_library(wdf01000 MODULE ${SOURCE})
182
+
183
+
# set_module_type(wdf01000 kernelmodedriver ENTRYPOINT 0)
184
+
# add_importlibs(wdf01000 ntoskrnl hal wdfldr)
185
+
# add_cd_file(TARGET wdf01000 DESTINATION reactos/system32/drivers FOR all)
186
+
# add_registry_inf(wdf01000_reg.inf)
187
+
188
+
add_library(wdf01000 ${SOURCE_SHARED} ${SOURCE_KM})
189
+
190
+
target_compile_definitions(wdf01000
191
+
PUBLIC WDF_DEVICE_NO_WDMSEC_H _WIN32_WINNT=0x603 NTDDI_VERSION=0x06030000 # NTDDI_WINBLUE
192
+
PRIVATE FX_CORE_MODE=1 FX_CORE_KERNEL_MODE=1
193
+
PRIVATE __WDF_MAJOR_VERSION=1 __WDF_MINOR_VERSION=17 __WDF_BUILD_NUMBER=7600)
194
+
195
+
target_include_directories(wdf01000
196
+
PUBLIC ${REACTOS_SOURCE_DIR}/sdk/include/wdf/kmdf/1.17
197
+
PRIVATE
198
+
shared/inc/primitives/common
199
+
shared/inc/primitives/km
200
+
shared/inc/private/common
201
+
shared/inc/private/km
202
+
kmdf/inc/private
203
+
shared/object # fxobjectpch.hpp
204
+
shared/support # fxsupportpch.hpp
205
+
shared/core # coreprivshared.hpp
206
+
shared/irphandlers # irphandlerspriv.hpp
207
+
shared/irphandlers/pnp # pnppriv.hpp
208
+
shared/irphandlers/pnp/km # pnpprivkm.hpp
209
+
)
210
+
211
+
target_link_libraries(wdf01000 ntoskrnl_vista ${PSEH_LIB})
212
+
213
+
if(GCC)
214
+
target_compile_options(wdf01000
215
+
PRIVATE -Wno-write-strings -Wno-unknown-pragmas -Wno-switch
216
+
PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-Wno-reorder -Wno-invalid-offsetof -Wno-delete-non-virtual-dtor>)
217
+
endif()
+105
-99
sdk/lib/drivers/wdf/kmdf/inc/private/fx.hpp
+105
-99
sdk/lib/drivers/wdf/kmdf/inc/private/fx.hpp
···
28
28
#include "mx.h"
29
29
}
30
30
31
-
#include "FxMacros.hpp"
31
+
#include "fxmacros.hpp"
32
32
33
33
extern "C" {
34
34
#include "wdf.h"
35
-
#include "wdmsec.h"
35
+
// #include "wdmsec.h"
36
36
#include "wdmguid.h"
37
37
38
-
#include "wdfdevicepri.h"
39
-
#include "wdfiotargetpri.h"
38
+
// #include "wdfdevicepri.h"
39
+
// #include "wdfiotargetpri.h"
40
40
#include "wdfcx.h"
41
41
#include "wdfldr.h"
42
42
43
-
#include <FxDynamicsWrapper.h>
43
+
#include <fxdynamicswrapper.h>
44
44
45
45
#include "wdf10.h"
46
46
#include "wdf11.h"
···
57
57
// Integer overflow functions
58
58
#include "ntintsafe.h"
59
59
60
-
#include "FxForward.hpp"
60
+
#include "fxforward.hpp"
61
61
62
62
//KMDF defines for shared type names
63
-
#include "FxTypeDefsKm.hpp"
63
+
#include "fxtypedefskm.hpp"
64
64
65
+
// #include "fxwmicompat.h"
66
+
// #include "fxtrace.h"
67
+
#if defined(EVENT_TRACING)
65
68
#include "fxwmicompat.h"
66
69
#include "fxtrace.h"
70
+
#else
71
+
#include "dbgtrace.h"
72
+
#endif // EVENT_TRACING
67
73
#include "fxtypes.h"
68
74
#include "fxrequestcontexttypes.h"
69
75
#include "fxpool.h"
70
-
#include "FxGlobalsKM.h"
71
-
#include "FxPoolInlines.hpp"
76
+
#include "fxglobalskm.h"
77
+
#include "fxpoolinlines.hpp"
72
78
#include "fxverifier.h"
73
79
#include "fxverifierkm.h"
74
-
#include "FxMdl.h"
75
-
#include "FxProbeAndLock.h"
80
+
#include "fxmdl.h"
81
+
#include "fxprobeandlock.h"
76
82
77
-
#include "FxPerfTraceKm.hpp"
78
-
#include "DriverFrameworks-KernelMode-KmEvents.h"
83
+
#include "fxperftracekm.hpp"
84
+
// #include "DriverFrameworks-KernelMode-KmEvents.h"
79
85
80
-
#include <NtStrSafe.h>
86
+
#include <ntstrsafe.h>
81
87
82
-
#include "FxStump.hpp"
88
+
#include "fxstump.hpp"
83
89
84
-
#include "FxRequestBuffer.hpp"
90
+
#include "fxrequestbuffer.hpp"
85
91
86
-
#include "FxTagTracker.hpp"
92
+
#include "fxtagtracker.hpp"
87
93
88
94
// internal locks
89
-
#include "FxVerifierLock.hpp"
90
-
#include "FxLock.hpp"
95
+
#include "fxverifierlock.hpp"
96
+
#include "fxlock.hpp"
91
97
92
98
// base objects
93
99
#include "fxobject.hpp"
94
-
#include "FxPagedObject.hpp"
95
-
#include "FxNonPagedObject.hpp"
100
+
#include "fxpagedobject.hpp"
101
+
#include "fxnonpagedobject.hpp"
96
102
97
103
#include "fxhandle.h"
98
104
99
105
// external locks
100
-
#include "FxWaitLock.hpp"
101
-
#include "FxSpinLock.hpp"
106
+
#include "fxwaitlock.hpp"
107
+
#include "fxspinlock.hpp"
102
108
103
109
// utitilty classes and functions
104
-
#include "FxTransactionedList.hpp"
105
-
#include "FxRelatedDeviceList.hpp"
106
-
#include "FxDisposeList.hpp"
107
-
#include "FxCollection.hpp"
108
-
#include "StringUtil.hpp"
110
+
#include "fxtransactionedlist.hpp"
111
+
#include "fxrelateddevicelist.hpp"
112
+
#include "fxdisposelist.hpp"
113
+
#include "fxcollection.hpp"
114
+
#include "stringutil.hpp"
109
115
110
116
// abstract classes
111
-
#include "IFxHasCallbacks.hpp"
117
+
#include "ifxhascallbacks.hpp"
112
118
113
119
// callback delegation and locking
114
-
#include "FxSystemThread.hpp"
115
-
#include "FxSystemWorkItem.hpp"
116
-
#include "FxCallbackLock.hpp"
117
-
#include "FxCallbackSpinLock.hpp"
118
-
#include "FxCallbackMutexLock.hpp"
119
-
#include "FxCallback.hpp"
120
-
#include "FxSystemThread.hpp"
120
+
#include "fxsystemthread.hpp"
121
+
#include "fxsystemworkitem.hpp"
122
+
#include "fxcallbacklock.hpp"
123
+
#include "fxcallbackspinlock.hpp"
124
+
#include "fxcallbackmutexlock.hpp"
125
+
#include "fxcallback.hpp"
126
+
#include "fxsystemthread.hpp"
121
127
122
-
#include "IFxMemory.hpp"
123
-
#include "FxLookasideList.hpp"
124
-
#include "FxNPagedLookasideList.hpp"
125
-
#include "FxPagedLookasideList.hpp"
126
-
#include "FxMemoryObject.hpp"
127
-
#include "FxMemoryBuffer.hpp"
128
-
#include "FxMemoryBufferFromPool.hpp"
129
-
#include "FxMemoryBufferPreallocated.hpp"
130
-
#include "FxMemoryBufferFromLookaside.hpp"
131
-
#include "FxRequestMemory.hpp"
132
-
#include "FxRegKey.hpp"
133
-
#include "FxAutoRegistry.hpp"
134
-
#include "FxAutoString.hpp"
135
-
#include "FxString.hpp"
128
+
#include "ifxmemory.hpp"
129
+
#include "fxlookasidelist.hpp"
130
+
#include "fxnpagedlookasidelist.hpp"
131
+
#include "fxpagedlookasidelist.hpp"
132
+
#include "fxmemoryobject.hpp"
133
+
#include "fxmemorybuffer.hpp"
134
+
#include "fxmemorybufferfrompool.hpp"
135
+
#include "fxmemorybufferpreallocated.hpp"
136
+
#include "fxmemorybufferfromlookaside.hpp"
137
+
#include "fxrequestmemory.hpp"
138
+
#include "fxregkey.hpp"
139
+
#include "fxautoregistry.hpp"
140
+
#include "fxautostring.hpp"
141
+
#include "fxstring.hpp"
136
142
137
-
#include "FxValidateFunctions.hpp"
138
-
#include "FxRequestValidateFunctions.hpp"
143
+
#include "fxvalidatefunctions.hpp"
144
+
#include "fxrequestvalidatefunctions.hpp"
139
145
140
-
#include "FxResource.hpp"
141
-
#include "FxRelatedDevice.hpp"
142
-
#include "FxDeviceInterface.hpp"
143
-
#include "FxQueryInterface.hpp"
144
-
#include "FxDeviceText.hpp"
146
+
#include "fxresource.hpp"
147
+
#include "fxrelateddevice.hpp"
148
+
#include "fxdeviceinterface.hpp"
149
+
#include "fxqueryinterface.hpp"
150
+
#include "fxdevicetext.hpp"
145
151
146
-
#include "FxIrp.hpp"
147
-
#include "FxDriver.hpp"
152
+
#include "fxirp.hpp"
153
+
#include "fxdriver.hpp"
148
154
149
155
// generic package interface
150
-
#include "FxPackage.hpp"
151
-
#include "FxPkgGeneral.hpp"
152
-
#include "FxDefaultIrpHandler.hpp"
153
-
#include "FxPkgPnp.hpp"
154
-
#include "FxWatchDog.hpp"
156
+
#include "fxpackage.hpp"
157
+
#include "fxpkggeneral.hpp"
158
+
#include "fxdefaultirphandler.hpp"
159
+
#include "fxpkgpnp.hpp"
160
+
#include "fxwatchdog.hpp"
155
161
156
162
// Device support
157
-
#include "FxChildList.hpp"
158
-
#include "FxCxDeviceInfo.hpp"
159
-
#include "FxDevice.hpp"
163
+
#include "fxchildlist.hpp"
164
+
#include "fxcxdeviceinfo.hpp"
165
+
#include "fxdevice.hpp"
160
166
161
-
#include "FxPkgIo.hpp"
167
+
#include "fxpkgio.hpp"
162
168
163
-
#include "FxDeviceToMxInterface.hpp"
169
+
#include "fxdevicetomxinterface.hpp"
164
170
165
-
#include "FxIrpQueue.hpp"
166
-
#include "FxRequestContext.hpp"
167
-
#include "FxRequestCallbacks.hpp"
168
-
#include "FxRequestBase.hpp"
169
-
#include "FxRequest.hpp"
170
-
#include "FxSyncRequest.hpp"
171
+
#include "fxirpqueue.hpp"
172
+
#include "fxrequestcontext.hpp"
173
+
#include "fxrequestcallbacks.hpp"
174
+
#include "fxrequestbase.hpp"
175
+
#include "fxrequest.hpp"
176
+
#include "fxsyncrequest.hpp"
171
177
172
178
// specialized irp handlers (ie packages)
173
-
#include "FxPkgFdo.hpp"
174
-
#include "FxPkgPdo.hpp"
175
-
#include "FxWmiIrpHandler.hpp"
176
-
#include "FxWmiProvider.hpp"
177
-
#include "FxWmiInstance.hpp"
179
+
#include "fxpkgfdo.hpp"
180
+
#include "fxpkgpdo.hpp"
181
+
#include "fxwmiirphandler.hpp"
182
+
#include "fxwmiprovider.hpp"
183
+
#include "fxwmiinstance.hpp"
178
184
179
185
// queus for read, write, (internal) IOCTL
180
-
#include "FxIoQueue.hpp"
181
-
#include "FxFileObject.hpp"
182
-
#include "FxIrpPreprocessInfo.hpp"
183
-
#include "FxIrpDynamicDispatchInfo.hpp"
186
+
#include "fxioqueue.hpp"
187
+
#include "fxfileobject.hpp"
188
+
#include "fxirppreprocessinfo.hpp"
189
+
#include "fxirpdynamicdispatchinfo.hpp"
184
190
185
-
#include "FxDpc.hpp"
186
-
#include "FxWorkItem.hpp"
187
-
#include "FxTimer.hpp"
188
-
#include "FxInterruptKm.hpp"
191
+
#include "fxdpc.hpp"
192
+
#include "fxworkitem.hpp"
193
+
#include "fxtimer.hpp"
194
+
#include "fxinterruptkm.hpp"
189
195
190
196
// IO targets (device lower edge interface)
191
-
#include "FxIoTarget.hpp"
192
-
#include "FxIoTargetRemote.hpp"
193
-
#include "FxIoTargetSelf.hpp"
197
+
#include "fxiotarget.hpp"
198
+
#include "fxiotargetremote.hpp"
199
+
#include "fxiotargetself.hpp"
194
200
195
-
#include "FxUsbDevice.hpp"
196
-
#include "FxUsbInterface.hpp"
197
-
#include "FxUsbPipe.hpp"
201
+
#include "fxusbdevice.hpp"
202
+
#include "fxusbinterface.hpp"
203
+
#include "fxusbpipe.hpp"
198
204
199
205
// DMA support
200
-
#include "FxDmaEnabler.hpp"
201
-
#include "FxDmaTransaction.hpp"
202
-
#include "FxCommonBuffer.hpp"
206
+
#include "fxdmaenabler.hpp"
207
+
#include "fxdmatransaction.hpp"
208
+
#include "fxcommonbuffer.hpp"
203
209
204
210
// Triage info.
205
-
#include "wdftriage.h"
211
+
// #include "wdftriage.h"
206
212
207
-
#include "FxTelemetry.hpp"
213
+
#include "fxtelemetry.hpp"
208
214
#endif // _FX_H
+8
-4
sdk/lib/drivers/wdf/kmdf/inc/private/fxdmatransaction.hpp
+8
-4
sdk/lib/drivers/wdf/kmdf/inc/private/fxdmatransaction.hpp
···
5
5
#define _FXDMATRANSACTION_HPP_
6
6
7
7
extern "C" {
8
-
#include "FxDmaTransaction.hpp.tmh"
8
+
// #include "FxDmaTransaction.hpp.tmh"
9
9
}
10
10
11
-
#include "FxDmaTransactionCallbacks.hpp"
11
+
#include "fxdmatransactioncallbacks.hpp"
12
12
13
13
//
14
14
// This type is used to allocate scatter-gather list of 1 element on the stack.
15
15
//
16
-
typedef __declspec(align(MEMORY_ALLOCATION_ALIGNMENT))UCHAR UCHAR_MEMORY_ALIGNED;
16
+
typedef DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) UCHAR UCHAR_MEMORY_ALIGNED;
17
17
18
18
// begin_wpp enum
19
19
···
912
912
protected:
913
913
914
914
inline
915
+
void
915
916
SetMapRegisterBase(
916
917
__in PVOID Value
917
918
)
···
924
925
}
925
926
926
927
inline
928
+
void
927
929
ClearMapRegisterBase(
928
930
VOID
929
931
)
···
934
936
}
935
937
936
938
inline
939
+
BOOLEAN
937
940
IsMapRegisterBaseSet(
938
941
VOID
939
942
)
···
1005
1008
1006
1009
static
1007
1010
IO_ALLOCATION_ACTION
1011
+
STDCALL
1008
1012
_AdapterControl(
1009
1013
__in PDEVICE_OBJECT DeviceObject,
1010
1014
__in PIRP Irp,
···
1528
1532
VOID
1529
1533
)
1530
1534
{
1531
-
__super::Reuse();
1535
+
FxDmaPacketTransaction::Reuse(); // __super call
1532
1536
m_ConfigureChannelFunction.Method = NULL;
1533
1537
m_ConfigureChannelContext = NULL;
1534
1538
+1046
-286
sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamics.h
+1046
-286
sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamics.h
···
14
14
#ifndef _FXDYNAMICS_H_
15
15
#define _FXDYNAMICS_H_
16
16
17
+
typedef WDFAPI NTSTATUS
18
+
(STDCALL *PFN_ROSWDFUNIMPLEMENTED)(VOID);
19
+
20
+
WDFAPI
21
+
NTSTATUS
22
+
STDCALL
23
+
WdfApiNotImplemented();
24
+
17
25
18
26
typedef struct _WDFFUNCTIONS {
19
27
···
38
46
PFN_WDFCOLLECTIONGETITEM pfnWdfCollectionGetItem;
39
47
PFN_WDFCOLLECTIONGETFIRSTITEM pfnWdfCollectionGetFirstItem;
40
48
PFN_WDFCOLLECTIONGETLASTITEM pfnWdfCollectionGetLastItem;
41
-
PFN_WDFCOMMONBUFFERCREATE pfnWdfCommonBufferCreate;
42
-
PFN_WDFCOMMONBUFFERGETALIGNEDVIRTUALADDRESS pfnWdfCommonBufferGetAlignedVirtualAddress;
43
-
PFN_WDFCOMMONBUFFERGETALIGNEDLOGICALADDRESS pfnWdfCommonBufferGetAlignedLogicalAddress;
44
-
PFN_WDFCOMMONBUFFERGETLENGTH pfnWdfCommonBufferGetLength;
49
+
// PFN_WDFCOMMONBUFFERCREATE pfnWdfCommonBufferCreate;
50
+
// PFN_WDFCOMMONBUFFERGETALIGNEDVIRTUALADDRESS pfnWdfCommonBufferGetAlignedVirtualAddress;
51
+
// PFN_WDFCOMMONBUFFERGETALIGNEDLOGICALADDRESS pfnWdfCommonBufferGetAlignedLogicalAddress;
52
+
// PFN_WDFCOMMONBUFFERGETLENGTH pfnWdfCommonBufferGetLength;
53
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferCreate;
54
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferGetAlignedVirtualAddress;
55
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferGetAlignedLogicalAddress;
56
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferGetLength;
57
+
45
58
PFN_WDFCONTROLDEVICEINITALLOCATE pfnWdfControlDeviceInitAllocate;
46
59
PFN_WDFCONTROLDEVICEINITSETSHUTDOWNNOTIFICATION pfnWdfControlDeviceInitSetShutdownNotification;
47
60
PFN_WDFCONTROLFINISHINITIALIZING pfnWdfControlFinishInitializing;
···
111
124
PFN_WDFDEVICEENQUEUEREQUEST pfnWdfDeviceEnqueueRequest;
112
125
PFN_WDFDEVICEGETDEFAULTQUEUE pfnWdfDeviceGetDefaultQueue;
113
126
PFN_WDFDEVICECONFIGUREREQUESTDISPATCHING pfnWdfDeviceConfigureRequestDispatching;
114
-
PFN_WDFDMAENABLERCREATE pfnWdfDmaEnablerCreate;
115
-
PFN_WDFDMAENABLERGETMAXIMUMLENGTH pfnWdfDmaEnablerGetMaximumLength;
116
-
PFN_WDFDMAENABLERGETMAXIMUMSCATTERGATHERELEMENTS pfnWdfDmaEnablerGetMaximumScatterGatherElements;
117
-
PFN_WDFDMAENABLERSETMAXIMUMSCATTERGATHERELEMENTS pfnWdfDmaEnablerSetMaximumScatterGatherElements;
118
-
PFN_WDFDMATRANSACTIONCREATE pfnWdfDmaTransactionCreate;
119
-
PFN_WDFDMATRANSACTIONINITIALIZE pfnWdfDmaTransactionInitialize;
120
-
PFN_WDFDMATRANSACTIONINITIALIZEUSINGREQUEST pfnWdfDmaTransactionInitializeUsingRequest;
121
-
PFN_WDFDMATRANSACTIONEXECUTE pfnWdfDmaTransactionExecute;
122
-
PFN_WDFDMATRANSACTIONRELEASE pfnWdfDmaTransactionRelease;
123
-
PFN_WDFDMATRANSACTIONDMACOMPLETED pfnWdfDmaTransactionDmaCompleted;
124
-
PFN_WDFDMATRANSACTIONDMACOMPLETEDWITHLENGTH pfnWdfDmaTransactionDmaCompletedWithLength;
125
-
PFN_WDFDMATRANSACTIONDMACOMPLETEDFINAL pfnWdfDmaTransactionDmaCompletedFinal;
126
-
PFN_WDFDMATRANSACTIONGETBYTESTRANSFERRED pfnWdfDmaTransactionGetBytesTransferred;
127
-
PFN_WDFDMATRANSACTIONSETMAXIMUMLENGTH pfnWdfDmaTransactionSetMaximumLength;
128
-
PFN_WDFDMATRANSACTIONGETREQUEST pfnWdfDmaTransactionGetRequest;
129
-
PFN_WDFDMATRANSACTIONGETCURRENTDMATRANSFERLENGTH pfnWdfDmaTransactionGetCurrentDmaTransferLength;
130
-
PFN_WDFDMATRANSACTIONGETDEVICE pfnWdfDmaTransactionGetDevice;
127
+
// PFN_WDFDMAENABLERCREATE pfnWdfDmaEnablerCreate;
128
+
// PFN_WDFDMAENABLERGETMAXIMUMLENGTH pfnWdfDmaEnablerGetMaximumLength;
129
+
// PFN_WDFDMAENABLERGETMAXIMUMSCATTERGATHERELEMENTS pfnWdfDmaEnablerGetMaximumScatterGatherElements;
130
+
// PFN_WDFDMAENABLERSETMAXIMUMSCATTERGATHERELEMENTS pfnWdfDmaEnablerSetMaximumScatterGatherElements;
131
+
// PFN_WDFDMATRANSACTIONCREATE pfnWdfDmaTransactionCreate;
132
+
// PFN_WDFDMATRANSACTIONINITIALIZE pfnWdfDmaTransactionInitialize;
133
+
// PFN_WDFDMATRANSACTIONINITIALIZEUSINGREQUEST pfnWdfDmaTransactionInitializeUsingRequest;
134
+
// PFN_WDFDMATRANSACTIONEXECUTE pfnWdfDmaTransactionExecute;
135
+
// PFN_WDFDMATRANSACTIONRELEASE pfnWdfDmaTransactionRelease;
136
+
// PFN_WDFDMATRANSACTIONDMACOMPLETED pfnWdfDmaTransactionDmaCompleted;
137
+
// PFN_WDFDMATRANSACTIONDMACOMPLETEDWITHLENGTH pfnWdfDmaTransactionDmaCompletedWithLength;
138
+
// PFN_WDFDMATRANSACTIONDMACOMPLETEDFINAL pfnWdfDmaTransactionDmaCompletedFinal;
139
+
// PFN_WDFDMATRANSACTIONGETBYTESTRANSFERRED pfnWdfDmaTransactionGetBytesTransferred;
140
+
// PFN_WDFDMATRANSACTIONSETMAXIMUMLENGTH pfnWdfDmaTransactionSetMaximumLength;
141
+
// PFN_WDFDMATRANSACTIONGETREQUEST pfnWdfDmaTransactionGetRequest;
142
+
// PFN_WDFDMATRANSACTIONGETCURRENTDMATRANSFERLENGTH pfnWdfDmaTransactionGetCurrentDmaTransferLength;
143
+
// PFN_WDFDMATRANSACTIONGETDEVICE pfnWdfDmaTransactionGetDevice;
144
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerCreate;
145
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerGetMaximumLength;
146
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerGetMaximumScatterGatherElements;
147
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerSetMaximumScatterGatherElements;
148
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionCreate;
149
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionInitialize;
150
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionInitializeUsingRequest;
151
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionExecute;
152
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionRelease;
153
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionDmaCompleted;
154
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionDmaCompletedWithLength;
155
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionDmaCompletedFinal;
156
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetBytesTransferred;
157
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetMaximumLength;
158
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetRequest;
159
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetCurrentDmaTransferLength;
160
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetDevice;
161
+
131
162
PFN_WDFDPCCREATE pfnWdfDpcCreate;
132
163
PFN_WDFDPCENQUEUE pfnWdfDpcEnqueue;
133
164
PFN_WDFDPCCANCEL pfnWdfDpcCancel;
···
158
189
PFN_WDFFILEOBJECTGETFLAGS pfnWdfFileObjectGetFlags;
159
190
PFN_WDFFILEOBJECTGETDEVICE pfnWdfFileObjectGetDevice;
160
191
PFN_WDFFILEOBJECTWDMGETFILEOBJECT pfnWdfFileObjectWdmGetFileObject;
161
-
PFN_WDFINTERRUPTCREATE pfnWdfInterruptCreate;
162
-
PFN_WDFINTERRUPTQUEUEDPCFORISR pfnWdfInterruptQueueDpcForIsr;
163
-
PFN_WDFINTERRUPTSYNCHRONIZE pfnWdfInterruptSynchronize;
164
-
PFN_WDFINTERRUPTACQUIRELOCK pfnWdfInterruptAcquireLock;
165
-
PFN_WDFINTERRUPTRELEASELOCK pfnWdfInterruptReleaseLock;
166
-
PFN_WDFINTERRUPTENABLE pfnWdfInterruptEnable;
167
-
PFN_WDFINTERRUPTDISABLE pfnWdfInterruptDisable;
168
-
PFN_WDFINTERRUPTWDMGETINTERRUPT pfnWdfInterruptWdmGetInterrupt;
169
-
PFN_WDFINTERRUPTGETINFO pfnWdfInterruptGetInfo;
170
-
PFN_WDFINTERRUPTSETPOLICY pfnWdfInterruptSetPolicy;
171
-
PFN_WDFINTERRUPTGETDEVICE pfnWdfInterruptGetDevice;
192
+
// PFN_WDFINTERRUPTCREATE pfnWdfInterruptCreate;
193
+
// PFN_WDFINTERRUPTQUEUEDPCFORISR pfnWdfInterruptQueueDpcForIsr;
194
+
// PFN_WDFINTERRUPTSYNCHRONIZE pfnWdfInterruptSynchronize;
195
+
// PFN_WDFINTERRUPTACQUIRELOCK pfnWdfInterruptAcquireLock;
196
+
// PFN_WDFINTERRUPTRELEASELOCK pfnWdfInterruptReleaseLock;
197
+
// PFN_WDFINTERRUPTENABLE pfnWdfInterruptEnable;
198
+
// PFN_WDFINTERRUPTDISABLE pfnWdfInterruptDisable;
199
+
// PFN_WDFINTERRUPTWDMGETINTERRUPT pfnWdfInterruptWdmGetInterrupt;
200
+
// PFN_WDFINTERRUPTGETINFO pfnWdfInterruptGetInfo;
201
+
// PFN_WDFINTERRUPTSETPOLICY pfnWdfInterruptSetPolicy;
202
+
// PFN_WDFINTERRUPTGETDEVICE pfnWdfInterruptGetDevice;
203
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptCreate;
204
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptQueueDpcForIsr;
205
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptSynchronize;
206
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptAcquireLock;
207
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptReleaseLock;
208
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptEnable;
209
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptDisable;
210
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptWdmGetInterrupt;
211
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptGetInfo;
212
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptSetPolicy;
213
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptGetDevice;
214
+
172
215
PFN_WDFIOQUEUECREATE pfnWdfIoQueueCreate;
173
216
PFN_WDFIOQUEUEGETSTATE pfnWdfIoQueueGetState;
174
217
PFN_WDFIOQUEUESTART pfnWdfIoQueueStart;
···
303
346
PFN_WDFREQUESTREQUEUE pfnWdfRequestRequeue;
304
347
PFN_WDFREQUESTSTOPACKNOWLEDGE pfnWdfRequestStopAcknowledge;
305
348
PFN_WDFREQUESTWDMGETIRP pfnWdfRequestWdmGetIrp;
306
-
PFN_WDFIORESOURCEREQUIREMENTSLISTSETSLOTNUMBER pfnWdfIoResourceRequirementsListSetSlotNumber;
307
-
PFN_WDFIORESOURCEREQUIREMENTSLISTSETINTERFACETYPE pfnWdfIoResourceRequirementsListSetInterfaceType;
308
-
PFN_WDFIORESOURCEREQUIREMENTSLISTAPPENDIORESLIST pfnWdfIoResourceRequirementsListAppendIoResList;
309
-
PFN_WDFIORESOURCEREQUIREMENTSLISTINSERTIORESLIST pfnWdfIoResourceRequirementsListInsertIoResList;
310
-
PFN_WDFIORESOURCEREQUIREMENTSLISTGETCOUNT pfnWdfIoResourceRequirementsListGetCount;
311
-
PFN_WDFIORESOURCEREQUIREMENTSLISTGETIORESLIST pfnWdfIoResourceRequirementsListGetIoResList;
312
-
PFN_WDFIORESOURCEREQUIREMENTSLISTREMOVE pfnWdfIoResourceRequirementsListRemove;
313
-
PFN_WDFIORESOURCEREQUIREMENTSLISTREMOVEBYIORESLIST pfnWdfIoResourceRequirementsListRemoveByIoResList;
314
-
PFN_WDFIORESOURCELISTCREATE pfnWdfIoResourceListCreate;
315
-
PFN_WDFIORESOURCELISTAPPENDDESCRIPTOR pfnWdfIoResourceListAppendDescriptor;
316
-
PFN_WDFIORESOURCELISTINSERTDESCRIPTOR pfnWdfIoResourceListInsertDescriptor;
317
-
PFN_WDFIORESOURCELISTUPDATEDESCRIPTOR pfnWdfIoResourceListUpdateDescriptor;
318
-
PFN_WDFIORESOURCELISTGETCOUNT pfnWdfIoResourceListGetCount;
319
-
PFN_WDFIORESOURCELISTGETDESCRIPTOR pfnWdfIoResourceListGetDescriptor;
320
-
PFN_WDFIORESOURCELISTREMOVE pfnWdfIoResourceListRemove;
321
-
PFN_WDFIORESOURCELISTREMOVEBYDESCRIPTOR pfnWdfIoResourceListRemoveByDescriptor;
322
-
PFN_WDFCMRESOURCELISTAPPENDDESCRIPTOR pfnWdfCmResourceListAppendDescriptor;
323
-
PFN_WDFCMRESOURCELISTINSERTDESCRIPTOR pfnWdfCmResourceListInsertDescriptor;
324
-
PFN_WDFCMRESOURCELISTGETCOUNT pfnWdfCmResourceListGetCount;
325
-
PFN_WDFCMRESOURCELISTGETDESCRIPTOR pfnWdfCmResourceListGetDescriptor;
326
-
PFN_WDFCMRESOURCELISTREMOVE pfnWdfCmResourceListRemove;
327
-
PFN_WDFCMRESOURCELISTREMOVEBYDESCRIPTOR pfnWdfCmResourceListRemoveByDescriptor;
349
+
// PFN_WDFIORESOURCEREQUIREMENTSLISTSETSLOTNUMBER pfnWdfIoResourceRequirementsListSetSlotNumber;
350
+
// PFN_WDFIORESOURCEREQUIREMENTSLISTSETINTERFACETYPE pfnWdfIoResourceRequirementsListSetInterfaceType;
351
+
// PFN_WDFIORESOURCEREQUIREMENTSLISTAPPENDIORESLIST pfnWdfIoResourceRequirementsListAppendIoResList;
352
+
// PFN_WDFIORESOURCEREQUIREMENTSLISTINSERTIORESLIST pfnWdfIoResourceRequirementsListInsertIoResList;
353
+
// PFN_WDFIORESOURCEREQUIREMENTSLISTGETCOUNT pfnWdfIoResourceRequirementsListGetCount;
354
+
// PFN_WDFIORESOURCEREQUIREMENTSLISTGETIORESLIST pfnWdfIoResourceRequirementsListGetIoResList;
355
+
// PFN_WDFIORESOURCEREQUIREMENTSLISTREMOVE pfnWdfIoResourceRequirementsListRemove;
356
+
// PFN_WDFIORESOURCEREQUIREMENTSLISTREMOVEBYIORESLIST pfnWdfIoResourceRequirementsListRemoveByIoResList;
357
+
// PFN_WDFIORESOURCELISTCREATE pfnWdfIoResourceListCreate;
358
+
// PFN_WDFIORESOURCELISTAPPENDDESCRIPTOR pfnWdfIoResourceListAppendDescriptor;
359
+
// PFN_WDFIORESOURCELISTINSERTDESCRIPTOR pfnWdfIoResourceListInsertDescriptor;
360
+
// PFN_WDFIORESOURCELISTUPDATEDESCRIPTOR pfnWdfIoResourceListUpdateDescriptor;
361
+
// PFN_WDFIORESOURCELISTGETCOUNT pfnWdfIoResourceListGetCount;
362
+
// PFN_WDFIORESOURCELISTGETDESCRIPTOR pfnWdfIoResourceListGetDescriptor;
363
+
// PFN_WDFIORESOURCELISTREMOVE pfnWdfIoResourceListRemove;
364
+
// PFN_WDFIORESOURCELISTREMOVEBYDESCRIPTOR pfnWdfIoResourceListRemoveByDescriptor;
365
+
// PFN_WDFCMRESOURCELISTAPPENDDESCRIPTOR pfnWdfCmResourceListAppendDescriptor;
366
+
// PFN_WDFCMRESOURCELISTINSERTDESCRIPTOR pfnWdfCmResourceListInsertDescriptor;
367
+
// PFN_WDFCMRESOURCELISTGETCOUNT pfnWdfCmResourceListGetCount;
368
+
// PFN_WDFCMRESOURCELISTGETDESCRIPTOR pfnWdfCmResourceListGetDescriptor;
369
+
// PFN_WDFCMRESOURCELISTREMOVE pfnWdfCmResourceListRemove;
370
+
// PFN_WDFCMRESOURCELISTREMOVEBYDESCRIPTOR pfnWdfCmResourceListRemoveByDescriptor;
371
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListSetSlotNumber;
372
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListSetInterfaceType;
373
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListAppendIoResList;
374
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListInsertIoResList;
375
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListGetCount;
376
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListGetIoResList;
377
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListRemove;
378
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceRequirementsListRemoveByIoResList;
379
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListCreate;
380
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListAppendDescriptor;
381
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListInsertDescriptor;
382
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListUpdateDescriptor;
383
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListGetCount;
384
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListGetDescriptor;
385
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListRemove;
386
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfIoResourceListRemoveByDescriptor;
387
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListAppendDescriptor;
388
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListInsertDescriptor;
389
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListGetCount;
390
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListGetDescriptor;
391
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListRemove;
392
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCmResourceListRemoveByDescriptor;
393
+
328
394
PFN_WDFSTRINGCREATE pfnWdfStringCreate;
329
395
PFN_WDFSTRINGGETUNICODESTRING pfnWdfStringGetUnicodeString;
330
396
PFN_WDFOBJECTACQUIRELOCK pfnWdfObjectAcquireLock;
···
339
405
PFN_WDFTIMERSTART pfnWdfTimerStart;
340
406
PFN_WDFTIMERSTOP pfnWdfTimerStop;
341
407
PFN_WDFTIMERGETPARENTOBJECT pfnWdfTimerGetParentObject;
342
-
PFN_WDFUSBTARGETDEVICECREATE pfnWdfUsbTargetDeviceCreate;
343
-
PFN_WDFUSBTARGETDEVICERETRIEVEINFORMATION pfnWdfUsbTargetDeviceRetrieveInformation;
344
-
PFN_WDFUSBTARGETDEVICEGETDEVICEDESCRIPTOR pfnWdfUsbTargetDeviceGetDeviceDescriptor;
345
-
PFN_WDFUSBTARGETDEVICERETRIEVECONFIGDESCRIPTOR pfnWdfUsbTargetDeviceRetrieveConfigDescriptor;
346
-
PFN_WDFUSBTARGETDEVICEQUERYSTRING pfnWdfUsbTargetDeviceQueryString;
347
-
PFN_WDFUSBTARGETDEVICEALLOCANDQUERYSTRING pfnWdfUsbTargetDeviceAllocAndQueryString;
348
-
PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORSTRING pfnWdfUsbTargetDeviceFormatRequestForString;
349
-
PFN_WDFUSBTARGETDEVICEGETNUMINTERFACES pfnWdfUsbTargetDeviceGetNumInterfaces;
350
-
PFN_WDFUSBTARGETDEVICESELECTCONFIG pfnWdfUsbTargetDeviceSelectConfig;
351
-
PFN_WDFUSBTARGETDEVICEWDMGETCONFIGURATIONHANDLE pfnWdfUsbTargetDeviceWdmGetConfigurationHandle;
352
-
PFN_WDFUSBTARGETDEVICERETRIEVECURRENTFRAMENUMBER pfnWdfUsbTargetDeviceRetrieveCurrentFrameNumber;
353
-
PFN_WDFUSBTARGETDEVICESENDCONTROLTRANSFERSYNCHRONOUSLY pfnWdfUsbTargetDeviceSendControlTransferSynchronously;
354
-
PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORCONTROLTRANSFER pfnWdfUsbTargetDeviceFormatRequestForControlTransfer;
355
-
PFN_WDFUSBTARGETDEVICEISCONNECTEDSYNCHRONOUS pfnWdfUsbTargetDeviceIsConnectedSynchronous;
356
-
PFN_WDFUSBTARGETDEVICERESETPORTSYNCHRONOUSLY pfnWdfUsbTargetDeviceResetPortSynchronously;
357
-
PFN_WDFUSBTARGETDEVICECYCLEPORTSYNCHRONOUSLY pfnWdfUsbTargetDeviceCyclePortSynchronously;
358
-
PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORCYCLEPORT pfnWdfUsbTargetDeviceFormatRequestForCyclePort;
359
-
PFN_WDFUSBTARGETDEVICESENDURBSYNCHRONOUSLY pfnWdfUsbTargetDeviceSendUrbSynchronously;
360
-
PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORURB pfnWdfUsbTargetDeviceFormatRequestForUrb;
361
-
PFN_WDFUSBTARGETPIPEGETINFORMATION pfnWdfUsbTargetPipeGetInformation;
362
-
PFN_WDFUSBTARGETPIPEISINENDPOINT pfnWdfUsbTargetPipeIsInEndpoint;
363
-
PFN_WDFUSBTARGETPIPEISOUTENDPOINT pfnWdfUsbTargetPipeIsOutEndpoint;
364
-
PFN_WDFUSBTARGETPIPEGETTYPE pfnWdfUsbTargetPipeGetType;
365
-
PFN_WDFUSBTARGETPIPESETNOMAXIMUMPACKETSIZECHECK pfnWdfUsbTargetPipeSetNoMaximumPacketSizeCheck;
366
-
PFN_WDFUSBTARGETPIPEWRITESYNCHRONOUSLY pfnWdfUsbTargetPipeWriteSynchronously;
367
-
PFN_WDFUSBTARGETPIPEFORMATREQUESTFORWRITE pfnWdfUsbTargetPipeFormatRequestForWrite;
368
-
PFN_WDFUSBTARGETPIPEREADSYNCHRONOUSLY pfnWdfUsbTargetPipeReadSynchronously;
369
-
PFN_WDFUSBTARGETPIPEFORMATREQUESTFORREAD pfnWdfUsbTargetPipeFormatRequestForRead;
370
-
PFN_WDFUSBTARGETPIPECONFIGCONTINUOUSREADER pfnWdfUsbTargetPipeConfigContinuousReader;
371
-
PFN_WDFUSBTARGETPIPEABORTSYNCHRONOUSLY pfnWdfUsbTargetPipeAbortSynchronously;
372
-
PFN_WDFUSBTARGETPIPEFORMATREQUESTFORABORT pfnWdfUsbTargetPipeFormatRequestForAbort;
373
-
PFN_WDFUSBTARGETPIPERESETSYNCHRONOUSLY pfnWdfUsbTargetPipeResetSynchronously;
374
-
PFN_WDFUSBTARGETPIPEFORMATREQUESTFORRESET pfnWdfUsbTargetPipeFormatRequestForReset;
375
-
PFN_WDFUSBTARGETPIPESENDURBSYNCHRONOUSLY pfnWdfUsbTargetPipeSendUrbSynchronously;
376
-
PFN_WDFUSBTARGETPIPEFORMATREQUESTFORURB pfnWdfUsbTargetPipeFormatRequestForUrb;
377
-
PFN_WDFUSBINTERFACEGETINTERFACENUMBER pfnWdfUsbInterfaceGetInterfaceNumber;
378
-
PFN_WDFUSBINTERFACEGETNUMENDPOINTS pfnWdfUsbInterfaceGetNumEndpoints;
379
-
PFN_WDFUSBINTERFACEGETDESCRIPTOR pfnWdfUsbInterfaceGetDescriptor;
380
-
PFN_WDFUSBINTERFACESELECTSETTING pfnWdfUsbInterfaceSelectSetting;
381
-
PFN_WDFUSBINTERFACEGETENDPOINTINFORMATION pfnWdfUsbInterfaceGetEndpointInformation;
382
-
PFN_WDFUSBTARGETDEVICEGETINTERFACE pfnWdfUsbTargetDeviceGetInterface;
383
-
PFN_WDFUSBINTERFACEGETCONFIGUREDSETTINGINDEX pfnWdfUsbInterfaceGetConfiguredSettingIndex;
384
-
PFN_WDFUSBINTERFACEGETNUMCONFIGUREDPIPES pfnWdfUsbInterfaceGetNumConfiguredPipes;
385
-
PFN_WDFUSBINTERFACEGETCONFIGUREDPIPE pfnWdfUsbInterfaceGetConfiguredPipe;
386
-
PFN_WDFUSBTARGETPIPEWDMGETPIPEHANDLE pfnWdfUsbTargetPipeWdmGetPipeHandle;
387
-
PFN_WDFVERIFIERDBGBREAKPOINT pfnWdfVerifierDbgBreakPoint;
388
-
PFN_WDFVERIFIERKEBUGCHECK pfnWdfVerifierKeBugCheck;
389
-
PFN_WDFWMIPROVIDERCREATE pfnWdfWmiProviderCreate;
390
-
PFN_WDFWMIPROVIDERGETDEVICE pfnWdfWmiProviderGetDevice;
391
-
PFN_WDFWMIPROVIDERISENABLED pfnWdfWmiProviderIsEnabled;
392
-
PFN_WDFWMIPROVIDERGETTRACINGHANDLE pfnWdfWmiProviderGetTracingHandle;
393
-
PFN_WDFWMIINSTANCECREATE pfnWdfWmiInstanceCreate;
394
-
PFN_WDFWMIINSTANCEREGISTER pfnWdfWmiInstanceRegister;
395
-
PFN_WDFWMIINSTANCEDEREGISTER pfnWdfWmiInstanceDeregister;
396
-
PFN_WDFWMIINSTANCEGETDEVICE pfnWdfWmiInstanceGetDevice;
397
-
PFN_WDFWMIINSTANCEGETPROVIDER pfnWdfWmiInstanceGetProvider;
398
-
PFN_WDFWMIINSTANCEFIREEVENT pfnWdfWmiInstanceFireEvent;
408
+
// PFN_WDFUSBTARGETDEVICECREATE pfnWdfUsbTargetDeviceCreate;
409
+
// PFN_WDFUSBTARGETDEVICERETRIEVEINFORMATION pfnWdfUsbTargetDeviceRetrieveInformation;
410
+
// PFN_WDFUSBTARGETDEVICEGETDEVICEDESCRIPTOR pfnWdfUsbTargetDeviceGetDeviceDescriptor;
411
+
// PFN_WDFUSBTARGETDEVICERETRIEVECONFIGDESCRIPTOR pfnWdfUsbTargetDeviceRetrieveConfigDescriptor;
412
+
// PFN_WDFUSBTARGETDEVICEQUERYSTRING pfnWdfUsbTargetDeviceQueryString;
413
+
// PFN_WDFUSBTARGETDEVICEALLOCANDQUERYSTRING pfnWdfUsbTargetDeviceAllocAndQueryString;
414
+
// PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORSTRING pfnWdfUsbTargetDeviceFormatRequestForString;
415
+
// PFN_WDFUSBTARGETDEVICEGETNUMINTERFACES pfnWdfUsbTargetDeviceGetNumInterfaces;
416
+
// PFN_WDFUSBTARGETDEVICESELECTCONFIG pfnWdfUsbTargetDeviceSelectConfig;
417
+
// PFN_WDFUSBTARGETDEVICEWDMGETCONFIGURATIONHANDLE pfnWdfUsbTargetDeviceWdmGetConfigurationHandle;
418
+
// PFN_WDFUSBTARGETDEVICERETRIEVECURRENTFRAMENUMBER pfnWdfUsbTargetDeviceRetrieveCurrentFrameNumber;
419
+
// PFN_WDFUSBTARGETDEVICESENDCONTROLTRANSFERSYNCHRONOUSLY pfnWdfUsbTargetDeviceSendControlTransferSynchronously;
420
+
// PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORCONTROLTRANSFER pfnWdfUsbTargetDeviceFormatRequestForControlTransfer;
421
+
// PFN_WDFUSBTARGETDEVICEISCONNECTEDSYNCHRONOUS pfnWdfUsbTargetDeviceIsConnectedSynchronous;
422
+
// PFN_WDFUSBTARGETDEVICERESETPORTSYNCHRONOUSLY pfnWdfUsbTargetDeviceResetPortSynchronously;
423
+
// PFN_WDFUSBTARGETDEVICECYCLEPORTSYNCHRONOUSLY pfnWdfUsbTargetDeviceCyclePortSynchronously;
424
+
// PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORCYCLEPORT pfnWdfUsbTargetDeviceFormatRequestForCyclePort;
425
+
// PFN_WDFUSBTARGETDEVICESENDURBSYNCHRONOUSLY pfnWdfUsbTargetDeviceSendUrbSynchronously;
426
+
// PFN_WDFUSBTARGETDEVICEFORMATREQUESTFORURB pfnWdfUsbTargetDeviceFormatRequestForUrb;
427
+
// PFN_WDFUSBTARGETPIPEGETINFORMATION pfnWdfUsbTargetPipeGetInformation;
428
+
// PFN_WDFUSBTARGETPIPEISINENDPOINT pfnWdfUsbTargetPipeIsInEndpoint;
429
+
// PFN_WDFUSBTARGETPIPEISOUTENDPOINT pfnWdfUsbTargetPipeIsOutEndpoint;
430
+
// PFN_WDFUSBTARGETPIPEGETTYPE pfnWdfUsbTargetPipeGetType;
431
+
// PFN_WDFUSBTARGETPIPESETNOMAXIMUMPACKETSIZECHECK pfnWdfUsbTargetPipeSetNoMaximumPacketSizeCheck;
432
+
// PFN_WDFUSBTARGETPIPEWRITESYNCHRONOUSLY pfnWdfUsbTargetPipeWriteSynchronously;
433
+
// PFN_WDFUSBTARGETPIPEFORMATREQUESTFORWRITE pfnWdfUsbTargetPipeFormatRequestForWrite;
434
+
// PFN_WDFUSBTARGETPIPEREADSYNCHRONOUSLY pfnWdfUsbTargetPipeReadSynchronously;
435
+
// PFN_WDFUSBTARGETPIPEFORMATREQUESTFORREAD pfnWdfUsbTargetPipeFormatRequestForRead;
436
+
// PFN_WDFUSBTARGETPIPECONFIGCONTINUOUSREADER pfnWdfUsbTargetPipeConfigContinuousReader;
437
+
// PFN_WDFUSBTARGETPIPEABORTSYNCHRONOUSLY pfnWdfUsbTargetPipeAbortSynchronously;
438
+
// PFN_WDFUSBTARGETPIPEFORMATREQUESTFORABORT pfnWdfUsbTargetPipeFormatRequestForAbort;
439
+
// PFN_WDFUSBTARGETPIPERESETSYNCHRONOUSLY pfnWdfUsbTargetPipeResetSynchronously;
440
+
// PFN_WDFUSBTARGETPIPEFORMATREQUESTFORRESET pfnWdfUsbTargetPipeFormatRequestForReset;
441
+
// PFN_WDFUSBTARGETPIPESENDURBSYNCHRONOUSLY pfnWdfUsbTargetPipeSendUrbSynchronously;
442
+
// PFN_WDFUSBTARGETPIPEFORMATREQUESTFORURB pfnWdfUsbTargetPipeFormatRequestForUrb;
443
+
// PFN_WDFUSBINTERFACEGETINTERFACENUMBER pfnWdfUsbInterfaceGetInterfaceNumber;
444
+
// PFN_WDFUSBINTERFACEGETNUMENDPOINTS pfnWdfUsbInterfaceGetNumEndpoints;
445
+
// PFN_WDFUSBINTERFACEGETDESCRIPTOR pfnWdfUsbInterfaceGetDescriptor;
446
+
// PFN_WDFUSBINTERFACESELECTSETTING pfnWdfUsbInterfaceSelectSetting;
447
+
// PFN_WDFUSBINTERFACEGETENDPOINTINFORMATION pfnWdfUsbInterfaceGetEndpointInformation;
448
+
// PFN_WDFUSBTARGETDEVICEGETINTERFACE pfnWdfUsbTargetDeviceGetInterface;
449
+
// PFN_WDFUSBINTERFACEGETCONFIGUREDSETTINGINDEX pfnWdfUsbInterfaceGetConfiguredSettingIndex;
450
+
// PFN_WDFUSBINTERFACEGETNUMCONFIGUREDPIPES pfnWdfUsbInterfaceGetNumConfiguredPipes;
451
+
// PFN_WDFUSBINTERFACEGETCONFIGUREDPIPE pfnWdfUsbInterfaceGetConfiguredPipe;
452
+
// PFN_WDFUSBTARGETPIPEWDMGETPIPEHANDLE pfnWdfUsbTargetPipeWdmGetPipeHandle;
453
+
// PFN_WDFVERIFIERDBGBREAKPOINT pfnWdfVerifierDbgBreakPoint;
454
+
// PFN_WDFVERIFIERKEBUGCHECK pfnWdfVerifierKeBugCheck;
455
+
// PFN_WDFWMIPROVIDERCREATE pfnWdfWmiProviderCreate;
456
+
// PFN_WDFWMIPROVIDERGETDEVICE pfnWdfWmiProviderGetDevice;
457
+
// PFN_WDFWMIPROVIDERISENABLED pfnWdfWmiProviderIsEnabled;
458
+
// PFN_WDFWMIPROVIDERGETTRACINGHANDLE pfnWdfWmiProviderGetTracingHandle;
459
+
// PFN_WDFWMIINSTANCECREATE pfnWdfWmiInstanceCreate;
460
+
// PFN_WDFWMIINSTANCEREGISTER pfnWdfWmiInstanceRegister;
461
+
// PFN_WDFWMIINSTANCEDEREGISTER pfnWdfWmiInstanceDeregister;
462
+
// PFN_WDFWMIINSTANCEGETDEVICE pfnWdfWmiInstanceGetDevice;
463
+
// PFN_WDFWMIINSTANCEGETPROVIDER pfnWdfWmiInstanceGetProvider;
464
+
// PFN_WDFWMIINSTANCEFIREEVENT pfnWdfWmiInstanceFireEvent;
465
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCreate;
466
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceRetrieveInformation;
467
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceGetDeviceDescriptor;
468
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceRetrieveConfigDescriptor;
469
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceQueryString;
470
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceAllocAndQueryString;
471
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceFormatRequestForString;
472
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceGetNumInterfaces;
473
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceSelectConfig;
474
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceWdmGetConfigurationHandle;
475
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceRetrieveCurrentFrameNumber;
476
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceSendControlTransferSynchronously;
477
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceFormatRequestForControlTransfer;
478
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceIsConnectedSynchronous;
479
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceResetPortSynchronously;
480
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCyclePortSynchronously;
481
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceFormatRequestForCyclePort;
482
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceSendUrbSynchronously;
483
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceFormatRequestForUrb;
484
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeGetInformation;
485
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeIsInEndpoint;
486
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeIsOutEndpoint;
487
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeGetType;
488
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeSetNoMaximumPacketSizeCheck;
489
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeWriteSynchronously;
490
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForWrite;
491
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeReadSynchronously;
492
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForRead;
493
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeConfigContinuousReader;
494
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeAbortSynchronously;
495
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForAbort;
496
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeResetSynchronously;
497
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForReset;
498
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeSendUrbSynchronously;
499
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeFormatRequestForUrb;
500
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetInterfaceNumber;
501
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetNumEndpoints;
502
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetDescriptor;
503
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceSelectSetting;
504
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetEndpointInformation;
505
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceGetInterface;
506
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetConfiguredSettingIndex;
507
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetNumConfiguredPipes;
508
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetConfiguredPipe;
509
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetPipeWdmGetPipeHandle;
510
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfVerifierDbgBreakPoint;
511
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfVerifierKeBugCheck;
512
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiProviderCreate;
513
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiProviderGetDevice;
514
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiProviderIsEnabled;
515
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiProviderGetTracingHandle;
516
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceCreate;
517
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceRegister;
518
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceDeregister;
519
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceGetDevice;
520
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceGetProvider;
521
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfWmiInstanceFireEvent;
522
+
399
523
PFN_WDFWORKITEMCREATE pfnWdfWorkItemCreate;
400
524
PFN_WDFWORKITEMENQUEUE pfnWdfWorkItemEnqueue;
401
525
PFN_WDFWORKITEMGETPARENTOBJECT pfnWdfWorkItemGetParentObject;
402
526
PFN_WDFWORKITEMFLUSH pfnWdfWorkItemFlush;
403
-
PFN_WDFCOMMONBUFFERCREATEWITHCONFIG pfnWdfCommonBufferCreateWithConfig;
404
-
PFN_WDFDMAENABLERGETFRAGMENTLENGTH pfnWdfDmaEnablerGetFragmentLength;
405
-
PFN_WDFDMAENABLERWDMGETDMAADAPTER pfnWdfDmaEnablerWdmGetDmaAdapter;
406
-
PFN_WDFUSBINTERFACEGETNUMSETTINGS pfnWdfUsbInterfaceGetNumSettings;
527
+
// PFN_WDFCOMMONBUFFERCREATEWITHCONFIG pfnWdfCommonBufferCreateWithConfig;
528
+
// PFN_WDFDMAENABLERGETFRAGMENTLENGTH pfnWdfDmaEnablerGetFragmentLength;
529
+
// PFN_WDFDMAENABLERWDMGETDMAADAPTER pfnWdfDmaEnablerWdmGetDmaAdapter;
530
+
// PFN_WDFUSBINTERFACEGETNUMSETTINGS pfnWdfUsbInterfaceGetNumSettings;
531
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCommonBufferCreateWithConfig;
532
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerGetFragmentLength;
533
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerWdmGetDmaAdapter;
534
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbInterfaceGetNumSettings;
535
+
407
536
PFN_WDFDEVICEREMOVEDEPENDENTUSAGEDEVICEOBJECT pfnWdfDeviceRemoveDependentUsageDeviceObject;
408
537
PFN_WDFDEVICEGETSYSTEMPOWERACTION pfnWdfDeviceGetSystemPowerAction;
409
-
PFN_WDFINTERRUPTSETEXTENDEDPOLICY pfnWdfInterruptSetExtendedPolicy;
538
+
// PFN_WDFINTERRUPTSETEXTENDEDPOLICY pfnWdfInterruptSetExtendedPolicy;
539
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptSetExtendedPolicy;
540
+
410
541
PFN_WDFIOQUEUEASSIGNFORWARDPROGRESSPOLICY pfnWdfIoQueueAssignForwardProgressPolicy;
411
542
PFN_WDFPDOINITASSIGNCONTAINERID pfnWdfPdoInitAssignContainerID;
412
543
PFN_WDFPDOINITALLOWFORWARDINGREQUESTTOPARENT pfnWdfPdoInitAllowForwardingRequestToParent;
413
544
PFN_WDFREQUESTMARKCANCELABLEEX pfnWdfRequestMarkCancelableEx;
414
545
PFN_WDFREQUESTISRESERVED pfnWdfRequestIsReserved;
415
546
PFN_WDFREQUESTFORWARDTOPARENTDEVICEIOQUEUE pfnWdfRequestForwardToParentDeviceIoQueue;
416
-
PFN_WDFCXDEVICEINITALLOCATE pfnWdfCxDeviceInitAllocate;
417
-
PFN_WDFCXDEVICEINITASSIGNWDMIRPPREPROCESSCALLBACK pfnWdfCxDeviceInitAssignWdmIrpPreprocessCallback;
418
-
PFN_WDFCXDEVICEINITSETIOINCALLERCONTEXTCALLBACK pfnWdfCxDeviceInitSetIoInCallerContextCallback;
419
-
PFN_WDFCXDEVICEINITSETREQUESTATTRIBUTES pfnWdfCxDeviceInitSetRequestAttributes;
420
-
PFN_WDFCXDEVICEINITSETFILEOBJECTCONFIG pfnWdfCxDeviceInitSetFileObjectConfig;
547
+
// PFN_WDFCXDEVICEINITALLOCATE pfnWdfCxDeviceInitAllocate;
548
+
// PFN_WDFCXDEVICEINITASSIGNWDMIRPPREPROCESSCALLBACK pfnWdfCxDeviceInitAssignWdmIrpPreprocessCallback;
549
+
// PFN_WDFCXDEVICEINITSETIOINCALLERCONTEXTCALLBACK pfnWdfCxDeviceInitSetIoInCallerContextCallback;
550
+
// PFN_WDFCXDEVICEINITSETREQUESTATTRIBUTES pfnWdfCxDeviceInitSetRequestAttributes;
551
+
// PFN_WDFCXDEVICEINITSETFILEOBJECTCONFIG pfnWdfCxDeviceInitSetFileObjectConfig;
552
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitAllocate;
553
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitAssignWdmIrpPreprocessCallback;
554
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitSetIoInCallerContextCallback;
555
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitSetRequestAttributes;
556
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCxDeviceInitSetFileObjectConfig;
557
+
421
558
PFN_WDFDEVICEWDMDISPATCHIRP pfnWdfDeviceWdmDispatchIrp;
422
559
PFN_WDFDEVICEWDMDISPATCHIRPTOIOQUEUE pfnWdfDeviceWdmDispatchIrpToIoQueue;
423
560
PFN_WDFDEVICEINITSETREMOVELOCKOPTIONS pfnWdfDeviceInitSetRemoveLockOptions;
424
561
PFN_WDFDEVICECONFIGUREWDMIRPDISPATCHCALLBACK pfnWdfDeviceConfigureWdmIrpDispatchCallback;
425
-
PFN_WDFDMAENABLERCONFIGURESYSTEMPROFILE pfnWdfDmaEnablerConfigureSystemProfile;
426
-
PFN_WDFDMATRANSACTIONINITIALIZEUSINGOFFSET pfnWdfDmaTransactionInitializeUsingOffset;
427
-
PFN_WDFDMATRANSACTIONGETTRANSFERINFO pfnWdfDmaTransactionGetTransferInfo;
428
-
PFN_WDFDMATRANSACTIONSETCHANNELCONFIGURATIONCALLBACK pfnWdfDmaTransactionSetChannelConfigurationCallback;
429
-
PFN_WDFDMATRANSACTIONSETTRANSFERCOMPLETECALLBACK pfnWdfDmaTransactionSetTransferCompleteCallback;
430
-
PFN_WDFDMATRANSACTIONSETIMMEDIATEEXECUTION pfnWdfDmaTransactionSetImmediateExecution;
431
-
PFN_WDFDMATRANSACTIONALLOCATERESOURCES pfnWdfDmaTransactionAllocateResources;
432
-
PFN_WDFDMATRANSACTIONSETDEVICEADDRESSOFFSET pfnWdfDmaTransactionSetDeviceAddressOffset;
433
-
PFN_WDFDMATRANSACTIONFREERESOURCES pfnWdfDmaTransactionFreeResources;
434
-
PFN_WDFDMATRANSACTIONCANCEL pfnWdfDmaTransactionCancel;
435
-
PFN_WDFDMATRANSACTIONWDMGETTRANSFERCONTEXT pfnWdfDmaTransactionWdmGetTransferContext;
436
-
PFN_WDFINTERRUPTQUEUEWORKITEMFORISR pfnWdfInterruptQueueWorkItemForIsr;
437
-
PFN_WDFINTERRUPTTRYTOACQUIRELOCK pfnWdfInterruptTryToAcquireLock;
562
+
// PFN_WDFDMAENABLERCONFIGURESYSTEMPROFILE pfnWdfDmaEnablerConfigureSystemProfile;
563
+
// PFN_WDFDMATRANSACTIONINITIALIZEUSINGOFFSET pfnWdfDmaTransactionInitializeUsingOffset;
564
+
// PFN_WDFDMATRANSACTIONGETTRANSFERINFO pfnWdfDmaTransactionGetTransferInfo;
565
+
// PFN_WDFDMATRANSACTIONSETCHANNELCONFIGURATIONCALLBACK pfnWdfDmaTransactionSetChannelConfigurationCallback;
566
+
// PFN_WDFDMATRANSACTIONSETTRANSFERCOMPLETECALLBACK pfnWdfDmaTransactionSetTransferCompleteCallback;
567
+
// PFN_WDFDMATRANSACTIONSETIMMEDIATEEXECUTION pfnWdfDmaTransactionSetImmediateExecution;
568
+
// PFN_WDFDMATRANSACTIONALLOCATERESOURCES pfnWdfDmaTransactionAllocateResources;
569
+
// PFN_WDFDMATRANSACTIONSETDEVICEADDRESSOFFSET pfnWdfDmaTransactionSetDeviceAddressOffset;
570
+
// PFN_WDFDMATRANSACTIONFREERESOURCES pfnWdfDmaTransactionFreeResources;
571
+
// PFN_WDFDMATRANSACTIONCANCEL pfnWdfDmaTransactionCancel;
572
+
// PFN_WDFDMATRANSACTIONWDMGETTRANSFERCONTEXT pfnWdfDmaTransactionWdmGetTransferContext;
573
+
// PFN_WDFINTERRUPTQUEUEWORKITEMFORISR pfnWdfInterruptQueueWorkItemForIsr;
574
+
// PFN_WDFINTERRUPTTRYTOACQUIRELOCK pfnWdfInterruptTryToAcquireLock;
575
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaEnablerConfigureSystemProfile;
576
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionInitializeUsingOffset;
577
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionGetTransferInfo;
578
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetChannelConfigurationCallback;
579
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetTransferCompleteCallback;
580
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetImmediateExecution;
581
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionAllocateResources;
582
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionSetDeviceAddressOffset;
583
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionFreeResources;
584
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionCancel;
585
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionWdmGetTransferContext;
586
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptQueueWorkItemForIsr;
587
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptTryToAcquireLock;
588
+
438
589
PFN_WDFIOQUEUESTOPANDPURGE pfnWdfIoQueueStopAndPurge;
439
590
PFN_WDFIOQUEUESTOPANDPURGESYNCHRONOUSLY pfnWdfIoQueueStopAndPurgeSynchronously;
440
591
PFN_WDFIOTARGETPURGE pfnWdfIoTargetPurge;
441
-
PFN_WDFUSBTARGETDEVICECREATEWITHPARAMETERS pfnWdfUsbTargetDeviceCreateWithParameters;
442
-
PFN_WDFUSBTARGETDEVICEQUERYUSBCAPABILITY pfnWdfUsbTargetDeviceQueryUsbCapability;
443
-
PFN_WDFUSBTARGETDEVICECREATEURB pfnWdfUsbTargetDeviceCreateUrb;
444
-
PFN_WDFUSBTARGETDEVICECREATEISOCHURB pfnWdfUsbTargetDeviceCreateIsochUrb;
592
+
// PFN_WDFUSBTARGETDEVICECREATEWITHPARAMETERS pfnWdfUsbTargetDeviceCreateWithParameters;
593
+
// PFN_WDFUSBTARGETDEVICEQUERYUSBCAPABILITY pfnWdfUsbTargetDeviceQueryUsbCapability;
594
+
// PFN_WDFUSBTARGETDEVICECREATEURB pfnWdfUsbTargetDeviceCreateUrb;
595
+
// PFN_WDFUSBTARGETDEVICECREATEISOCHURB pfnWdfUsbTargetDeviceCreateIsochUrb;
596
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCreateWithParameters;
597
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceQueryUsbCapability;
598
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCreateUrb;
599
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfUsbTargetDeviceCreateIsochUrb;
600
+
445
601
PFN_WDFDEVICEWDMASSIGNPOWERFRAMEWORKSETTINGS pfnWdfDeviceWdmAssignPowerFrameworkSettings;
446
-
PFN_WDFDMATRANSACTIONSTOPSYSTEMTRANSFER pfnWdfDmaTransactionStopSystemTransfer;
447
-
PFN_WDFCXVERIFIERKEBUGCHECK pfnWdfCxVerifierKeBugCheck;
448
-
PFN_WDFINTERRUPTREPORTACTIVE pfnWdfInterruptReportActive;
449
-
PFN_WDFINTERRUPTREPORTINACTIVE pfnWdfInterruptReportInactive;
602
+
// PFN_WDFDMATRANSACTIONSTOPSYSTEMTRANSFER pfnWdfDmaTransactionStopSystemTransfer;
603
+
// PFN_WDFCXVERIFIERKEBUGCHECK pfnWdfCxVerifierKeBugCheck;
604
+
// PFN_WDFINTERRUPTREPORTACTIVE pfnWdfInterruptReportActive;
605
+
// PFN_WDFINTERRUPTREPORTINACTIVE pfnWdfInterruptReportInactive;
606
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfDmaTransactionStopSystemTransfer;
607
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfCxVerifierKeBugCheck;
608
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptReportActive;
609
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfInterruptReportInactive;
610
+
450
611
PFN_WDFDEVICEINITSETRELEASEHARDWAREORDERONFAILURE pfnWdfDeviceInitSetReleaseHardwareOrderOnFailure;
451
-
PFN_WDFGETTRIAGEINFO pfnWdfGetTriageInfo;
612
+
// PFN_WDFGETTRIAGEINFO pfnWdfGetTriageInfo;
613
+
PFN_ROSWDFUNIMPLEMENTED pfnWdfGetTriageInfo;
614
+
452
615
PFN_WDFDEVICEINITSETIOTYPEEX pfnWdfDeviceInitSetIoTypeEx;
453
616
PFN_WDFDEVICEQUERYPROPERTYEX pfnWdfDeviceQueryPropertyEx;
454
617
PFN_WDFDEVICEALLOCANDQUERYPROPERTYEX pfnWdfDeviceAllocAndQueryPropertyEx;
···
478
641
_IRQL_requires_max_(PASSIVE_LEVEL)
479
642
WDFAPI
480
643
NTSTATUS
644
+
STDCALL
481
645
WDFEXPORT(WdfChildListCreate)(
482
646
_In_
483
647
PWDF_DRIVER_GLOBALS DriverGlobals,
···
494
658
_IRQL_requires_max_(DISPATCH_LEVEL)
495
659
WDFAPI
496
660
WDFDEVICE
661
+
STDCALL
497
662
WDFEXPORT(WdfChildListGetDevice)(
498
663
_In_
499
664
PWDF_DRIVER_GLOBALS DriverGlobals,
···
505
670
_IRQL_requires_max_(DISPATCH_LEVEL)
506
671
WDFAPI
507
672
WDFDEVICE
673
+
STDCALL
508
674
WDFEXPORT(WdfChildListRetrievePdo)(
509
675
_In_
510
676
PWDF_DRIVER_GLOBALS DriverGlobals,
···
518
684
_IRQL_requires_max_(DISPATCH_LEVEL)
519
685
WDFAPI
520
686
NTSTATUS
687
+
STDCALL
521
688
WDFEXPORT(WdfChildListRetrieveAddressDescription)(
522
689
_In_
523
690
PWDF_DRIVER_GLOBALS DriverGlobals,
···
532
699
_IRQL_requires_max_(DISPATCH_LEVEL)
533
700
WDFAPI
534
701
VOID
702
+
STDCALL
535
703
WDFEXPORT(WdfChildListBeginScan)(
536
704
_In_
537
705
PWDF_DRIVER_GLOBALS DriverGlobals,
···
542
710
_IRQL_requires_max_(DISPATCH_LEVEL)
543
711
WDFAPI
544
712
VOID
713
+
STDCALL
545
714
WDFEXPORT(WdfChildListEndScan)(
546
715
_In_
547
716
PWDF_DRIVER_GLOBALS DriverGlobals,
···
552
721
_IRQL_requires_max_(DISPATCH_LEVEL)
553
722
WDFAPI
554
723
VOID
724
+
STDCALL
555
725
WDFEXPORT(WdfChildListBeginIteration)(
556
726
_In_
557
727
PWDF_DRIVER_GLOBALS DriverGlobals,
···
565
735
_IRQL_requires_max_(DISPATCH_LEVEL)
566
736
WDFAPI
567
737
NTSTATUS
738
+
STDCALL
568
739
WDFEXPORT(WdfChildListRetrieveNextDevice)(
569
740
_In_
570
741
PWDF_DRIVER_GLOBALS DriverGlobals,
···
581
752
_IRQL_requires_max_(DISPATCH_LEVEL)
582
753
WDFAPI
583
754
VOID
755
+
STDCALL
584
756
WDFEXPORT(WdfChildListEndIteration)(
585
757
_In_
586
758
PWDF_DRIVER_GLOBALS DriverGlobals,
···
594
766
_IRQL_requires_max_(DISPATCH_LEVEL)
595
767
WDFAPI
596
768
NTSTATUS
769
+
STDCALL
597
770
WDFEXPORT(WdfChildListAddOrUpdateChildDescriptionAsPresent)(
598
771
_In_
599
772
PWDF_DRIVER_GLOBALS DriverGlobals,
···
609
782
_IRQL_requires_max_(DISPATCH_LEVEL)
610
783
WDFAPI
611
784
NTSTATUS
785
+
STDCALL
612
786
WDFEXPORT(WdfChildListUpdateChildDescriptionAsMissing)(
613
787
_In_
614
788
PWDF_DRIVER_GLOBALS DriverGlobals,
···
621
795
_IRQL_requires_max_(DISPATCH_LEVEL)
622
796
WDFAPI
623
797
VOID
798
+
STDCALL
624
799
WDFEXPORT(WdfChildListUpdateAllChildDescriptionsAsPresent)(
625
800
_In_
626
801
PWDF_DRIVER_GLOBALS DriverGlobals,
···
631
806
_IRQL_requires_max_(DISPATCH_LEVEL)
632
807
WDFAPI
633
808
BOOLEAN
809
+
STDCALL
634
810
WDFEXPORT(WdfChildListRequestChildEject)(
635
811
_In_
636
812
PWDF_DRIVER_GLOBALS DriverGlobals,
···
644
820
_IRQL_requires_max_(DISPATCH_LEVEL)
645
821
WDFAPI
646
822
NTSTATUS
823
+
STDCALL
647
824
WDFEXPORT(WdfCollectionCreate)(
648
825
_In_
649
826
PWDF_DRIVER_GLOBALS DriverGlobals,
···
656
833
_IRQL_requires_max_(DISPATCH_LEVEL)
657
834
WDFAPI
658
835
ULONG
836
+
STDCALL
659
837
WDFEXPORT(WdfCollectionGetCount)(
660
838
_In_
661
839
PWDF_DRIVER_GLOBALS DriverGlobals,
···
667
845
_IRQL_requires_max_(DISPATCH_LEVEL)
668
846
WDFAPI
669
847
NTSTATUS
848
+
STDCALL
670
849
WDFEXPORT(WdfCollectionAdd)(
671
850
_In_
672
851
PWDF_DRIVER_GLOBALS DriverGlobals,
···
679
858
_IRQL_requires_max_(DISPATCH_LEVEL)
680
859
WDFAPI
681
860
VOID
861
+
STDCALL
682
862
WDFEXPORT(WdfCollectionRemove)(
683
863
_In_
684
864
PWDF_DRIVER_GLOBALS DriverGlobals,
···
691
871
_IRQL_requires_max_(DISPATCH_LEVEL)
692
872
WDFAPI
693
873
VOID
874
+
STDCALL
694
875
WDFEXPORT(WdfCollectionRemoveItem)(
695
876
_In_
696
877
PWDF_DRIVER_GLOBALS DriverGlobals,
···
703
884
_IRQL_requires_max_(DISPATCH_LEVEL)
704
885
WDFAPI
705
886
WDFOBJECT
887
+
STDCALL
706
888
WDFEXPORT(WdfCollectionGetItem)(
707
889
_In_
708
890
PWDF_DRIVER_GLOBALS DriverGlobals,
···
715
897
_IRQL_requires_max_(DISPATCH_LEVEL)
716
898
WDFAPI
717
899
WDFOBJECT
900
+
STDCALL
718
901
WDFEXPORT(WdfCollectionGetFirstItem)(
719
902
_In_
720
903
PWDF_DRIVER_GLOBALS DriverGlobals,
···
725
908
_IRQL_requires_max_(DISPATCH_LEVEL)
726
909
WDFAPI
727
910
WDFOBJECT
911
+
STDCALL
728
912
WDFEXPORT(WdfCollectionGetLastItem)(
729
913
_In_
730
914
PWDF_DRIVER_GLOBALS DriverGlobals,
···
736
920
_IRQL_requires_max_(PASSIVE_LEVEL)
737
921
WDFAPI
738
922
NTSTATUS
923
+
STDCALL
739
924
WDFEXPORT(WdfCommonBufferCreate)(
740
925
_In_
741
926
PWDF_DRIVER_GLOBALS DriverGlobals,
···
754
939
_IRQL_requires_max_(PASSIVE_LEVEL)
755
940
WDFAPI
756
941
NTSTATUS
942
+
STDCALL
757
943
WDFEXPORT(WdfCommonBufferCreateWithConfig)(
758
944
_In_
759
945
PWDF_DRIVER_GLOBALS DriverGlobals,
···
773
959
_IRQL_requires_max_(DISPATCH_LEVEL)
774
960
WDFAPI
775
961
PVOID
962
+
STDCALL
776
963
WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress)(
777
964
_In_
778
965
PWDF_DRIVER_GLOBALS DriverGlobals,
···
783
970
_IRQL_requires_max_(DISPATCH_LEVEL)
784
971
WDFAPI
785
972
PHYSICAL_ADDRESS
973
+
STDCALL
786
974
WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress)(
787
975
_In_
788
976
PWDF_DRIVER_GLOBALS DriverGlobals,
···
793
981
_IRQL_requires_max_(DISPATCH_LEVEL)
794
982
WDFAPI
795
983
size_t
984
+
STDCALL
796
985
WDFEXPORT(WdfCommonBufferGetLength)(
797
986
_In_
798
987
PWDF_DRIVER_GLOBALS DriverGlobals,
···
804
993
_IRQL_requires_max_(PASSIVE_LEVEL)
805
994
WDFAPI
806
995
PWDFDEVICE_INIT
996
+
STDCALL
807
997
WDFEXPORT(WdfControlDeviceInitAllocate)(
808
998
_In_
809
999
PWDF_DRIVER_GLOBALS DriverGlobals,
···
816
1006
_IRQL_requires_max_(PASSIVE_LEVEL)
817
1007
WDFAPI
818
1008
VOID
1009
+
STDCALL
819
1010
WDFEXPORT(WdfControlDeviceInitSetShutdownNotification)(
820
1011
_In_
821
1012
PWDF_DRIVER_GLOBALS DriverGlobals,
···
830
1021
_IRQL_requires_max_(DISPATCH_LEVEL)
831
1022
WDFAPI
832
1023
VOID
1024
+
STDCALL
833
1025
WDFEXPORT(WdfControlFinishInitializing)(
834
1026
_In_
835
1027
PWDF_DRIVER_GLOBALS DriverGlobals,
···
841
1033
_IRQL_requires_max_(PASSIVE_LEVEL)
842
1034
WDFAPI
843
1035
PWDFCXDEVICE_INIT
1036
+
STDCALL
844
1037
WDFEXPORT(WdfCxDeviceInitAllocate)(
845
1038
_In_
846
1039
PWDF_DRIVER_GLOBALS DriverGlobals,
···
852
1045
_IRQL_requires_max_(DISPATCH_LEVEL)
853
1046
WDFAPI
854
1047
NTSTATUS
1048
+
STDCALL
855
1049
WDFEXPORT(WdfCxDeviceInitAssignWdmIrpPreprocessCallback)(
856
1050
_In_
857
1051
PWDF_DRIVER_GLOBALS DriverGlobals,
···
871
1065
_IRQL_requires_max_(DISPATCH_LEVEL)
872
1066
WDFAPI
873
1067
VOID
1068
+
STDCALL
874
1069
WDFEXPORT(WdfCxDeviceInitSetIoInCallerContextCallback)(
875
1070
_In_
876
1071
PWDF_DRIVER_GLOBALS DriverGlobals,
···
883
1078
_IRQL_requires_max_(DISPATCH_LEVEL)
884
1079
WDFAPI
885
1080
VOID
1081
+
STDCALL
886
1082
WDFEXPORT(WdfCxDeviceInitSetRequestAttributes)(
887
1083
_In_
888
1084
PWDF_DRIVER_GLOBALS DriverGlobals,
···
895
1091
_IRQL_requires_max_(DISPATCH_LEVEL)
896
1092
WDFAPI
897
1093
VOID
1094
+
STDCALL
898
1095
WDFEXPORT(WdfCxDeviceInitSetFileObjectConfig)(
899
1096
_In_
900
1097
PWDF_DRIVER_GLOBALS DriverGlobals,
···
908
1105
909
1106
WDFAPI
910
1107
VOID
1108
+
STDCALL
911
1109
WDFEXPORT(WdfCxVerifierKeBugCheck)(
912
1110
_In_
913
1111
PWDF_DRIVER_GLOBALS DriverGlobals,
···
928
1126
_IRQL_requires_max_(DISPATCH_LEVEL)
929
1127
WDFAPI
930
1128
VOID
1129
+
STDCALL
931
1130
WDFEXPORT(WdfDeviceGetDeviceState)(
932
1131
_In_
933
1132
PWDF_DRIVER_GLOBALS DriverGlobals,
···
940
1139
_IRQL_requires_max_(DISPATCH_LEVEL)
941
1140
WDFAPI
942
1141
VOID
1142
+
STDCALL
943
1143
WDFEXPORT(WdfDeviceSetDeviceState)(
944
1144
_In_
945
1145
PWDF_DRIVER_GLOBALS DriverGlobals,
···
952
1152
_IRQL_requires_max_(DISPATCH_LEVEL)
953
1153
WDFAPI
954
1154
WDFDEVICE
1155
+
STDCALL
955
1156
WDFEXPORT(WdfWdmDeviceGetWdfDeviceHandle)(
956
1157
_In_
957
1158
PWDF_DRIVER_GLOBALS DriverGlobals,
···
962
1163
_IRQL_requires_max_(DISPATCH_LEVEL)
963
1164
WDFAPI
964
1165
PDEVICE_OBJECT
1166
+
STDCALL
965
1167
WDFEXPORT(WdfDeviceWdmGetDeviceObject)(
966
1168
_In_
967
1169
PWDF_DRIVER_GLOBALS DriverGlobals,
···
972
1174
_IRQL_requires_max_(DISPATCH_LEVEL)
973
1175
WDFAPI
974
1176
PDEVICE_OBJECT
1177
+
STDCALL
975
1178
WDFEXPORT(WdfDeviceWdmGetAttachedDevice)(
976
1179
_In_
977
1180
PWDF_DRIVER_GLOBALS DriverGlobals,
···
982
1185
_IRQL_requires_max_(DISPATCH_LEVEL)
983
1186
WDFAPI
984
1187
PDEVICE_OBJECT
1188
+
STDCALL
985
1189
WDFEXPORT(WdfDeviceWdmGetPhysicalDevice)(
986
1190
_In_
987
1191
PWDF_DRIVER_GLOBALS DriverGlobals,
···
993
1197
_IRQL_requires_max_(DISPATCH_LEVEL)
994
1198
WDFAPI
995
1199
NTSTATUS
1200
+
STDCALL
996
1201
WDFEXPORT(WdfDeviceWdmDispatchPreprocessedIrp)(
997
1202
_In_
998
1203
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1006
1211
_IRQL_requires_max_(DISPATCH_LEVEL)
1007
1212
WDFAPI
1008
1213
NTSTATUS
1214
+
STDCALL
1009
1215
WDFEXPORT(WdfDeviceWdmDispatchIrp)(
1010
1216
_In_
1011
1217
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1021
1227
_IRQL_requires_max_(DISPATCH_LEVEL)
1022
1228
WDFAPI
1023
1229
NTSTATUS
1230
+
STDCALL
1024
1231
WDFEXPORT(WdfDeviceWdmDispatchIrpToIoQueue)(
1025
1232
_In_
1026
1233
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1038
1245
_IRQL_requires_max_(DISPATCH_LEVEL)
1039
1246
WDFAPI
1040
1247
NTSTATUS
1248
+
STDCALL
1041
1249
WDFEXPORT(WdfDeviceAddDependentUsageDeviceObject)(
1042
1250
_In_
1043
1251
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1050
1258
_IRQL_requires_max_(DISPATCH_LEVEL)
1051
1259
WDFAPI
1052
1260
VOID
1261
+
STDCALL
1053
1262
WDFEXPORT(WdfDeviceRemoveDependentUsageDeviceObject)(
1054
1263
_In_
1055
1264
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1063
1272
_IRQL_requires_max_(DISPATCH_LEVEL)
1064
1273
WDFAPI
1065
1274
NTSTATUS
1275
+
STDCALL
1066
1276
WDFEXPORT(WdfDeviceAddRemovalRelationsPhysicalDevice)(
1067
1277
_In_
1068
1278
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1075
1285
_IRQL_requires_max_(DISPATCH_LEVEL)
1076
1286
WDFAPI
1077
1287
VOID
1288
+
STDCALL
1078
1289
WDFEXPORT(WdfDeviceRemoveRemovalRelationsPhysicalDevice)(
1079
1290
_In_
1080
1291
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1087
1298
_IRQL_requires_max_(DISPATCH_LEVEL)
1088
1299
WDFAPI
1089
1300
VOID
1301
+
STDCALL
1090
1302
WDFEXPORT(WdfDeviceClearRemovalRelationsDevices)(
1091
1303
_In_
1092
1304
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1097
1309
_IRQL_requires_max_(DISPATCH_LEVEL)
1098
1310
WDFAPI
1099
1311
WDFDRIVER
1312
+
STDCALL
1100
1313
WDFEXPORT(WdfDeviceGetDriver)(
1101
1314
_In_
1102
1315
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1108
1321
_IRQL_requires_max_(PASSIVE_LEVEL)
1109
1322
WDFAPI
1110
1323
NTSTATUS
1324
+
STDCALL
1111
1325
WDFEXPORT(WdfDeviceRetrieveDeviceName)(
1112
1326
_In_
1113
1327
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1121
1335
_IRQL_requires_max_(PASSIVE_LEVEL)
1122
1336
WDFAPI
1123
1337
NTSTATUS
1338
+
STDCALL
1124
1339
WDFEXPORT(WdfDeviceAssignMofResourceName)(
1125
1340
_In_
1126
1341
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1133
1348
_IRQL_requires_max_(DISPATCH_LEVEL)
1134
1349
WDFAPI
1135
1350
WDFIOTARGET
1351
+
STDCALL
1136
1352
WDFEXPORT(WdfDeviceGetIoTarget)(
1137
1353
_In_
1138
1354
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1143
1359
_IRQL_requires_max_(DISPATCH_LEVEL)
1144
1360
WDFAPI
1145
1361
WDF_DEVICE_PNP_STATE
1362
+
STDCALL
1146
1363
WDFEXPORT(WdfDeviceGetDevicePnpState)(
1147
1364
_In_
1148
1365
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1153
1370
_IRQL_requires_max_(DISPATCH_LEVEL)
1154
1371
WDFAPI
1155
1372
WDF_DEVICE_POWER_STATE
1373
+
STDCALL
1156
1374
WDFEXPORT(WdfDeviceGetDevicePowerState)(
1157
1375
_In_
1158
1376
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1163
1381
_IRQL_requires_max_(DISPATCH_LEVEL)
1164
1382
WDFAPI
1165
1383
WDF_DEVICE_POWER_POLICY_STATE
1384
+
STDCALL
1166
1385
WDFEXPORT(WdfDeviceGetDevicePowerPolicyState)(
1167
1386
_In_
1168
1387
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1174
1393
_IRQL_requires_max_(DISPATCH_LEVEL)
1175
1394
WDFAPI
1176
1395
NTSTATUS
1396
+
STDCALL
1177
1397
WDFEXPORT(WdfDeviceAssignS0IdleSettings)(
1178
1398
_In_
1179
1399
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1187
1407
_IRQL_requires_max_(DISPATCH_LEVEL)
1188
1408
WDFAPI
1189
1409
NTSTATUS
1410
+
STDCALL
1190
1411
WDFEXPORT(WdfDeviceAssignSxWakeSettings)(
1191
1412
_In_
1192
1413
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1200
1421
_IRQL_requires_max_(PASSIVE_LEVEL)
1201
1422
WDFAPI
1202
1423
NTSTATUS
1424
+
STDCALL
1203
1425
WDFEXPORT(WdfDeviceOpenRegistryKey)(
1204
1426
_In_
1205
1427
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1219
1441
_IRQL_requires_max_(PASSIVE_LEVEL)
1220
1442
WDFAPI
1221
1443
NTSTATUS
1444
+
STDCALL
1222
1445
WDFEXPORT(WdfDeviceOpenDevicemapKey)(
1223
1446
_In_
1224
1447
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1237
1460
_IRQL_requires_max_(DISPATCH_LEVEL)
1238
1461
WDFAPI
1239
1462
VOID
1463
+
STDCALL
1240
1464
WDFEXPORT(WdfDeviceSetSpecialFileSupport)(
1241
1465
_In_
1242
1466
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1251
1475
_IRQL_requires_max_(DISPATCH_LEVEL)
1252
1476
WDFAPI
1253
1477
VOID
1478
+
STDCALL
1254
1479
WDFEXPORT(WdfDeviceSetCharacteristics)(
1255
1480
_In_
1256
1481
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1263
1488
_IRQL_requires_max_(DISPATCH_LEVEL)
1264
1489
WDFAPI
1265
1490
ULONG
1491
+
STDCALL
1266
1492
WDFEXPORT(WdfDeviceGetCharacteristics)(
1267
1493
_In_
1268
1494
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1273
1499
_IRQL_requires_max_(DISPATCH_LEVEL)
1274
1500
WDFAPI
1275
1501
ULONG
1502
+
STDCALL
1276
1503
WDFEXPORT(WdfDeviceGetAlignmentRequirement)(
1277
1504
_In_
1278
1505
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1283
1510
_IRQL_requires_max_(DISPATCH_LEVEL)
1284
1511
WDFAPI
1285
1512
VOID
1513
+
STDCALL
1286
1514
WDFEXPORT(WdfDeviceSetAlignmentRequirement)(
1287
1515
_In_
1288
1516
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1295
1523
_IRQL_requires_max_(DISPATCH_LEVEL)
1296
1524
WDFAPI
1297
1525
VOID
1526
+
STDCALL
1298
1527
WDFEXPORT(WdfDeviceInitFree)(
1299
1528
_In_
1300
1529
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1305
1534
_IRQL_requires_max_(DISPATCH_LEVEL)
1306
1535
WDFAPI
1307
1536
VOID
1537
+
STDCALL
1308
1538
WDFEXPORT(WdfDeviceInitSetPnpPowerEventCallbacks)(
1309
1539
_In_
1310
1540
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1317
1547
_IRQL_requires_max_(DISPATCH_LEVEL)
1318
1548
WDFAPI
1319
1549
VOID
1550
+
STDCALL
1320
1551
WDFEXPORT(WdfDeviceInitSetPowerPolicyEventCallbacks)(
1321
1552
_In_
1322
1553
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1329
1560
_IRQL_requires_max_(DISPATCH_LEVEL)
1330
1561
WDFAPI
1331
1562
VOID
1563
+
STDCALL
1332
1564
WDFEXPORT(WdfDeviceInitSetPowerPolicyOwnership)(
1333
1565
_In_
1334
1566
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1342
1574
_IRQL_requires_max_(PASSIVE_LEVEL)
1343
1575
WDFAPI
1344
1576
NTSTATUS
1577
+
STDCALL
1345
1578
WDFEXPORT(WdfDeviceInitRegisterPnpStateChangeCallback)(
1346
1579
_In_
1347
1580
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1359
1592
_IRQL_requires_max_(PASSIVE_LEVEL)
1360
1593
WDFAPI
1361
1594
NTSTATUS
1595
+
STDCALL
1362
1596
WDFEXPORT(WdfDeviceInitRegisterPowerStateChangeCallback)(
1363
1597
_In_
1364
1598
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1376
1610
_IRQL_requires_max_(PASSIVE_LEVEL)
1377
1611
WDFAPI
1378
1612
NTSTATUS
1613
+
STDCALL
1379
1614
WDFEXPORT(WdfDeviceInitRegisterPowerPolicyStateChangeCallback)(
1380
1615
_In_
1381
1616
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1392
1627
_IRQL_requires_max_(DISPATCH_LEVEL)
1393
1628
WDFAPI
1394
1629
VOID
1630
+
STDCALL
1395
1631
WDFEXPORT(WdfDeviceInitSetExclusive)(
1396
1632
_In_
1397
1633
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1404
1640
_IRQL_requires_max_(DISPATCH_LEVEL)
1405
1641
WDFAPI
1406
1642
VOID
1643
+
STDCALL
1407
1644
WDFEXPORT(WdfDeviceInitSetIoType)(
1408
1645
_In_
1409
1646
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1416
1653
_IRQL_requires_max_(DISPATCH_LEVEL)
1417
1654
WDFAPI
1418
1655
VOID
1656
+
STDCALL
1419
1657
WDFEXPORT(WdfDeviceInitSetPowerNotPageable)(
1420
1658
_In_
1421
1659
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1426
1664
_IRQL_requires_max_(DISPATCH_LEVEL)
1427
1665
WDFAPI
1428
1666
VOID
1667
+
STDCALL
1429
1668
WDFEXPORT(WdfDeviceInitSetPowerPageable)(
1430
1669
_In_
1431
1670
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1436
1675
_IRQL_requires_max_(DISPATCH_LEVEL)
1437
1676
WDFAPI
1438
1677
VOID
1678
+
STDCALL
1439
1679
WDFEXPORT(WdfDeviceInitSetPowerInrush)(
1440
1680
_In_
1441
1681
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1446
1686
_IRQL_requires_max_(DISPATCH_LEVEL)
1447
1687
WDFAPI
1448
1688
VOID
1689
+
STDCALL
1449
1690
WDFEXPORT(WdfDeviceInitSetDeviceType)(
1450
1691
_In_
1451
1692
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1459
1700
_IRQL_requires_max_(PASSIVE_LEVEL)
1460
1701
WDFAPI
1461
1702
NTSTATUS
1703
+
STDCALL
1462
1704
WDFEXPORT(WdfDeviceInitAssignName)(
1463
1705
_In_
1464
1706
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1472
1714
_IRQL_requires_max_(PASSIVE_LEVEL)
1473
1715
WDFAPI
1474
1716
NTSTATUS
1717
+
STDCALL
1475
1718
WDFEXPORT(WdfDeviceInitAssignSDDLString)(
1476
1719
_In_
1477
1720
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1484
1727
_IRQL_requires_max_(DISPATCH_LEVEL)
1485
1728
WDFAPI
1486
1729
VOID
1730
+
STDCALL
1487
1731
WDFEXPORT(WdfDeviceInitSetDeviceClass)(
1488
1732
_In_
1489
1733
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1496
1740
_IRQL_requires_max_(DISPATCH_LEVEL)
1497
1741
WDFAPI
1498
1742
VOID
1743
+
STDCALL
1499
1744
WDFEXPORT(WdfDeviceInitSetCharacteristics)(
1500
1745
_In_
1501
1746
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1510
1755
_IRQL_requires_max_(DISPATCH_LEVEL)
1511
1756
WDFAPI
1512
1757
VOID
1758
+
STDCALL
1513
1759
WDFEXPORT(WdfDeviceInitSetFileObjectConfig)(
1514
1760
_In_
1515
1761
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1524
1770
_IRQL_requires_max_(DISPATCH_LEVEL)
1525
1771
WDFAPI
1526
1772
VOID
1773
+
STDCALL
1527
1774
WDFEXPORT(WdfDeviceInitSetRequestAttributes)(
1528
1775
_In_
1529
1776
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1537
1784
_IRQL_requires_max_(DISPATCH_LEVEL)
1538
1785
WDFAPI
1539
1786
NTSTATUS
1787
+
STDCALL
1540
1788
WDFEXPORT(WdfDeviceInitAssignWdmIrpPreprocessCallback)(
1541
1789
_In_
1542
1790
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1556
1804
_IRQL_requires_max_(DISPATCH_LEVEL)
1557
1805
WDFAPI
1558
1806
VOID
1807
+
STDCALL
1559
1808
WDFEXPORT(WdfDeviceInitSetIoInCallerContextCallback)(
1560
1809
_In_
1561
1810
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1568
1817
_IRQL_requires_max_(DISPATCH_LEVEL)
1569
1818
WDFAPI
1570
1819
VOID
1820
+
STDCALL
1571
1821
WDFEXPORT(WdfDeviceInitSetRemoveLockOptions)(
1572
1822
_In_
1573
1823
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1581
1831
_IRQL_requires_max_(PASSIVE_LEVEL)
1582
1832
WDFAPI
1583
1833
NTSTATUS
1834
+
STDCALL
1584
1835
WDFEXPORT(WdfDeviceCreate)(
1585
1836
_In_
1586
1837
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1595
1846
_IRQL_requires_max_(DISPATCH_LEVEL)
1596
1847
WDFAPI
1597
1848
VOID
1849
+
STDCALL
1598
1850
WDFEXPORT(WdfDeviceSetStaticStopRemove)(
1599
1851
_In_
1600
1852
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1608
1860
_IRQL_requires_max_(PASSIVE_LEVEL)
1609
1861
WDFAPI
1610
1862
NTSTATUS
1863
+
STDCALL
1611
1864
WDFEXPORT(WdfDeviceCreateDeviceInterface)(
1612
1865
_In_
1613
1866
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1622
1875
_IRQL_requires_max_(PASSIVE_LEVEL)
1623
1876
WDFAPI
1624
1877
VOID
1878
+
STDCALL
1625
1879
WDFEXPORT(WdfDeviceSetDeviceInterfaceState)(
1626
1880
_In_
1627
1881
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1639
1893
_IRQL_requires_max_(PASSIVE_LEVEL)
1640
1894
WDFAPI
1641
1895
NTSTATUS
1896
+
STDCALL
1642
1897
WDFEXPORT(WdfDeviceRetrieveDeviceInterfaceString)(
1643
1898
_In_
1644
1899
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1656
1911
_IRQL_requires_max_(PASSIVE_LEVEL)
1657
1912
WDFAPI
1658
1913
NTSTATUS
1914
+
STDCALL
1659
1915
WDFEXPORT(WdfDeviceCreateSymbolicLink)(
1660
1916
_In_
1661
1917
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1669
1925
_IRQL_requires_max_(PASSIVE_LEVEL)
1670
1926
WDFAPI
1671
1927
NTSTATUS
1928
+
STDCALL
1672
1929
WDFEXPORT(WdfDeviceQueryProperty)(
1673
1930
_In_
1674
1931
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1688
1945
_IRQL_requires_max_(PASSIVE_LEVEL)
1689
1946
WDFAPI
1690
1947
NTSTATUS
1948
+
STDCALL
1691
1949
WDFEXPORT(WdfDeviceAllocAndQueryProperty)(
1692
1950
_In_
1693
1951
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1707
1965
_IRQL_requires_max_(DISPATCH_LEVEL)
1708
1966
WDFAPI
1709
1967
VOID
1968
+
STDCALL
1710
1969
WDFEXPORT(WdfDeviceSetPnpCapabilities)(
1711
1970
_In_
1712
1971
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1719
1978
_IRQL_requires_max_(DISPATCH_LEVEL)
1720
1979
WDFAPI
1721
1980
VOID
1981
+
STDCALL
1722
1982
WDFEXPORT(WdfDeviceSetPowerCapabilities)(
1723
1983
_In_
1724
1984
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1731
1991
_IRQL_requires_max_(DISPATCH_LEVEL)
1732
1992
WDFAPI
1733
1993
VOID
1994
+
STDCALL
1734
1995
WDFEXPORT(WdfDeviceSetBusInformationForChildren)(
1735
1996
_In_
1736
1997
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1744
2005
_IRQL_requires_max_(DISPATCH_LEVEL)
1745
2006
WDFAPI
1746
2007
NTSTATUS
2008
+
STDCALL
1747
2009
WDFEXPORT(WdfDeviceIndicateWakeStatus)(
1748
2010
_In_
1749
2011
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1756
2018
_IRQL_requires_max_(DISPATCH_LEVEL)
1757
2019
WDFAPI
1758
2020
VOID
2021
+
STDCALL
1759
2022
WDFEXPORT(WdfDeviceSetFailed)(
1760
2023
_In_
1761
2024
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1770
2033
_When_(WaitForD0 != 0, _IRQL_requires_max_(PASSIVE_LEVEL))
1771
2034
WDFAPI
1772
2035
NTSTATUS
2036
+
STDCALL
1773
2037
WDFEXPORT(WdfDeviceStopIdleNoTrack)(
1774
2038
_In_
1775
2039
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1782
2046
_IRQL_requires_max_(DISPATCH_LEVEL)
1783
2047
WDFAPI
1784
2048
VOID
2049
+
STDCALL
1785
2050
WDFEXPORT(WdfDeviceResumeIdleNoTrack)(
1786
2051
_In_
1787
2052
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1794
2059
_When_(WaitForD0 != 0, _IRQL_requires_max_(PASSIVE_LEVEL))
1795
2060
WDFAPI
1796
2061
NTSTATUS
2062
+
STDCALL
1797
2063
WDFEXPORT(WdfDeviceStopIdleActual)(
1798
2064
_In_
1799
2065
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1812
2078
_IRQL_requires_max_(DISPATCH_LEVEL)
1813
2079
WDFAPI
1814
2080
VOID
2081
+
STDCALL
1815
2082
WDFEXPORT(WdfDeviceResumeIdleActual)(
1816
2083
_In_
1817
2084
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1828
2095
_IRQL_requires_max_(DISPATCH_LEVEL)
1829
2096
WDFAPI
1830
2097
WDFFILEOBJECT
2098
+
STDCALL
1831
2099
WDFEXPORT(WdfDeviceGetFileObject)(
1832
2100
_In_
1833
2101
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1841
2109
_IRQL_requires_max_(DISPATCH_LEVEL)
1842
2110
WDFAPI
1843
2111
NTSTATUS
2112
+
STDCALL
1844
2113
WDFEXPORT(WdfDeviceEnqueueRequest)(
1845
2114
_In_
1846
2115
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1853
2122
_IRQL_requires_max_(DISPATCH_LEVEL)
1854
2123
WDFAPI
1855
2124
WDFQUEUE
2125
+
STDCALL
1856
2126
WDFEXPORT(WdfDeviceGetDefaultQueue)(
1857
2127
_In_
1858
2128
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1864
2134
_IRQL_requires_max_(DISPATCH_LEVEL)
1865
2135
WDFAPI
1866
2136
NTSTATUS
2137
+
STDCALL
1867
2138
WDFEXPORT(WdfDeviceConfigureRequestDispatching)(
1868
2139
_In_
1869
2140
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1880
2151
_IRQL_requires_max_(DISPATCH_LEVEL)
1881
2152
WDFAPI
1882
2153
NTSTATUS
2154
+
STDCALL
1883
2155
WDFEXPORT(WdfDeviceConfigureWdmIrpDispatchCallback)(
1884
2156
_In_
1885
2157
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1898
2170
_IRQL_requires_max_(DISPATCH_LEVEL)
1899
2171
WDFAPI
1900
2172
POWER_ACTION
2173
+
STDCALL
1901
2174
WDFEXPORT(WdfDeviceGetSystemPowerAction)(
1902
2175
_In_
1903
2176
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1909
2182
_IRQL_requires_max_(PASSIVE_LEVEL)
1910
2183
WDFAPI
1911
2184
NTSTATUS
2185
+
STDCALL
1912
2186
WDFEXPORT(WdfDeviceWdmAssignPowerFrameworkSettings)(
1913
2187
_In_
1914
2188
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1921
2195
_IRQL_requires_max_(DISPATCH_LEVEL)
1922
2196
WDFAPI
1923
2197
VOID
2198
+
STDCALL
1924
2199
WDFEXPORT(WdfDeviceInitSetReleaseHardwareOrderOnFailure)(
1925
2200
_In_
1926
2201
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1933
2208
_IRQL_requires_max_(PASSIVE_LEVEL)
1934
2209
WDFAPI
1935
2210
VOID
2211
+
STDCALL
1936
2212
WDFEXPORT(WdfDeviceInitSetIoTypeEx)(
1937
2213
_In_
1938
2214
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1946
2222
_IRQL_requires_max_(APC_LEVEL)
1947
2223
WDFAPI
1948
2224
NTSTATUS
2225
+
STDCALL
1949
2226
WDFEXPORT(WdfDeviceQueryPropertyEx)(
1950
2227
_In_
1951
2228
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1967
2244
_IRQL_requires_max_(APC_LEVEL)
1968
2245
WDFAPI
1969
2246
NTSTATUS
2247
+
STDCALL
1970
2248
WDFEXPORT(WdfDeviceAllocAndQueryPropertyEx)(
1971
2249
_In_
1972
2250
PWDF_DRIVER_GLOBALS DriverGlobals,
···
1989
2267
_IRQL_requires_max_(APC_LEVEL)
1990
2268
WDFAPI
1991
2269
NTSTATUS
2270
+
STDCALL
1992
2271
WDFEXPORT(WdfDeviceAssignProperty)(
1993
2272
_In_
1994
2273
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2007
2286
_IRQL_requires_max_(DISPATCH_LEVEL)
2008
2287
WDFAPI
2009
2288
WDFIOTARGET
2289
+
STDCALL
2010
2290
WDFEXPORT(WdfDeviceGetSelfIoTarget)(
2011
2291
_In_
2012
2292
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2017
2297
_IRQL_requires_max_(DISPATCH_LEVEL)
2018
2298
WDFAPI
2019
2299
VOID
2300
+
STDCALL
2020
2301
WDFEXPORT(WdfDeviceInitAllowSelfIoTarget)(
2021
2302
_In_
2022
2303
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2028
2309
_IRQL_requires_max_(PASSIVE_LEVEL)
2029
2310
WDFAPI
2030
2311
NTSTATUS
2312
+
STDCALL
2031
2313
WDFEXPORT(WdfDmaEnablerCreate)(
2032
2314
_In_
2033
2315
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2045
2327
_IRQL_requires_max_(PASSIVE_LEVEL)
2046
2328
WDFAPI
2047
2329
NTSTATUS
2330
+
STDCALL
2048
2331
WDFEXPORT(WdfDmaEnablerConfigureSystemProfile)(
2049
2332
_In_
2050
2333
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2059
2342
_IRQL_requires_max_(DISPATCH_LEVEL)
2060
2343
WDFAPI
2061
2344
size_t
2345
+
STDCALL
2062
2346
WDFEXPORT(WdfDmaEnablerGetMaximumLength)(
2063
2347
_In_
2064
2348
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2069
2353
_IRQL_requires_max_(DISPATCH_LEVEL)
2070
2354
WDFAPI
2071
2355
size_t
2356
+
STDCALL
2072
2357
WDFEXPORT(WdfDmaEnablerGetMaximumScatterGatherElements)(
2073
2358
_In_
2074
2359
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2079
2364
_IRQL_requires_max_(PASSIVE_LEVEL)
2080
2365
WDFAPI
2081
2366
VOID
2367
+
STDCALL
2082
2368
WDFEXPORT(WdfDmaEnablerSetMaximumScatterGatherElements)(
2083
2369
_In_
2084
2370
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2092
2378
_IRQL_requires_max_(DISPATCH_LEVEL)
2093
2379
WDFAPI
2094
2380
size_t
2381
+
STDCALL
2095
2382
WDFEXPORT(WdfDmaEnablerGetFragmentLength)(
2096
2383
_In_
2097
2384
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2104
2391
_IRQL_requires_max_(DISPATCH_LEVEL)
2105
2392
WDFAPI
2106
2393
PDMA_ADAPTER
2394
+
STDCALL
2107
2395
WDFEXPORT(WdfDmaEnablerWdmGetDmaAdapter)(
2108
2396
_In_
2109
2397
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2117
2405
_IRQL_requires_max_(DISPATCH_LEVEL)
2118
2406
WDFAPI
2119
2407
NTSTATUS
2408
+
STDCALL
2120
2409
WDFEXPORT(WdfDmaTransactionCreate)(
2121
2410
_In_
2122
2411
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2132
2421
_IRQL_requires_max_(DISPATCH_LEVEL)
2133
2422
WDFAPI
2134
2423
NTSTATUS
2424
+
STDCALL
2135
2425
WDFEXPORT(WdfDmaTransactionInitialize)(
2136
2426
_In_
2137
2427
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2154
2444
_IRQL_requires_max_(DISPATCH_LEVEL)
2155
2445
WDFAPI
2156
2446
NTSTATUS
2447
+
STDCALL
2157
2448
WDFEXPORT(WdfDmaTransactionInitializeUsingOffset)(
2158
2449
_In_
2159
2450
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2176
2467
_IRQL_requires_max_(DISPATCH_LEVEL)
2177
2468
WDFAPI
2178
2469
NTSTATUS
2470
+
STDCALL
2179
2471
WDFEXPORT(WdfDmaTransactionInitializeUsingRequest)(
2180
2472
_In_
2181
2473
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2193
2485
_IRQL_requires_max_(DISPATCH_LEVEL)
2194
2486
WDFAPI
2195
2487
NTSTATUS
2488
+
STDCALL
2196
2489
WDFEXPORT(WdfDmaTransactionExecute)(
2197
2490
_In_
2198
2491
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2206
2499
_IRQL_requires_max_(DISPATCH_LEVEL)
2207
2500
WDFAPI
2208
2501
NTSTATUS
2502
+
STDCALL
2209
2503
WDFEXPORT(WdfDmaTransactionRelease)(
2210
2504
_In_
2211
2505
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2216
2510
_IRQL_requires_max_(DISPATCH_LEVEL)
2217
2511
WDFAPI
2218
2512
BOOLEAN
2513
+
STDCALL
2219
2514
WDFEXPORT(WdfDmaTransactionDmaCompleted)(
2220
2515
_In_
2221
2516
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2228
2523
_IRQL_requires_max_(DISPATCH_LEVEL)
2229
2524
WDFAPI
2230
2525
BOOLEAN
2526
+
STDCALL
2231
2527
WDFEXPORT(WdfDmaTransactionDmaCompletedWithLength)(
2232
2528
_In_
2233
2529
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2242
2538
_IRQL_requires_max_(DISPATCH_LEVEL)
2243
2539
WDFAPI
2244
2540
BOOLEAN
2541
+
STDCALL
2245
2542
WDFEXPORT(WdfDmaTransactionDmaCompletedFinal)(
2246
2543
_In_
2247
2544
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2256
2553
_IRQL_requires_max_(DISPATCH_LEVEL)
2257
2554
WDFAPI
2258
2555
size_t
2556
+
STDCALL
2259
2557
WDFEXPORT(WdfDmaTransactionGetBytesTransferred)(
2260
2558
_In_
2261
2559
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2266
2564
_IRQL_requires_max_(DISPATCH_LEVEL)
2267
2565
WDFAPI
2268
2566
VOID
2567
+
STDCALL
2269
2568
WDFEXPORT(WdfDmaTransactionSetMaximumLength)(
2270
2569
_In_
2271
2570
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2278
2577
_IRQL_requires_max_(DISPATCH_LEVEL)
2279
2578
WDFAPI
2280
2579
WDFREQUEST
2580
+
STDCALL
2281
2581
WDFEXPORT(WdfDmaTransactionGetRequest)(
2282
2582
_In_
2283
2583
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2288
2588
_IRQL_requires_max_(DISPATCH_LEVEL)
2289
2589
WDFAPI
2290
2590
size_t
2591
+
STDCALL
2291
2592
WDFEXPORT(WdfDmaTransactionGetCurrentDmaTransferLength)(
2292
2593
_In_
2293
2594
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2298
2599
_IRQL_requires_max_(DISPATCH_LEVEL)
2299
2600
WDFAPI
2300
2601
WDFDEVICE
2602
+
STDCALL
2301
2603
WDFEXPORT(WdfDmaTransactionGetDevice)(
2302
2604
_In_
2303
2605
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2308
2610
_IRQL_requires_max_(DISPATCH_LEVEL)
2309
2611
WDFAPI
2310
2612
VOID
2613
+
STDCALL
2311
2614
WDFEXPORT(WdfDmaTransactionGetTransferInfo)(
2312
2615
_In_
2313
2616
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2322
2625
_IRQL_requires_max_(DISPATCH_LEVEL)
2323
2626
WDFAPI
2324
2627
VOID
2628
+
STDCALL
2325
2629
WDFEXPORT(WdfDmaTransactionSetChannelConfigurationCallback)(
2326
2630
_In_
2327
2631
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2336
2640
_IRQL_requires_max_(DISPATCH_LEVEL)
2337
2641
WDFAPI
2338
2642
VOID
2643
+
STDCALL
2339
2644
WDFEXPORT(WdfDmaTransactionSetTransferCompleteCallback)(
2340
2645
_In_
2341
2646
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2350
2655
_IRQL_requires_max_(DISPATCH_LEVEL)
2351
2656
WDFAPI
2352
2657
VOID
2658
+
STDCALL
2353
2659
WDFEXPORT(WdfDmaTransactionSetImmediateExecution)(
2354
2660
_In_
2355
2661
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2362
2668
_IRQL_requires_max_(DISPATCH_LEVEL)
2363
2669
WDFAPI
2364
2670
NTSTATUS
2671
+
STDCALL
2365
2672
WDFEXPORT(WdfDmaTransactionAllocateResources)(
2366
2673
_In_
2367
2674
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2380
2687
_IRQL_requires_max_(DISPATCH_LEVEL)
2381
2688
WDFAPI
2382
2689
VOID
2690
+
STDCALL
2383
2691
WDFEXPORT(WdfDmaTransactionSetDeviceAddressOffset)(
2384
2692
_In_
2385
2693
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2392
2700
_IRQL_requires_max_(DISPATCH_LEVEL)
2393
2701
WDFAPI
2394
2702
VOID
2703
+
STDCALL
2395
2704
WDFEXPORT(WdfDmaTransactionFreeResources)(
2396
2705
_In_
2397
2706
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2402
2711
_IRQL_requires_max_(DISPATCH_LEVEL)
2403
2712
WDFAPI
2404
2713
BOOLEAN
2714
+
STDCALL
2405
2715
WDFEXPORT(WdfDmaTransactionCancel)(
2406
2716
_In_
2407
2717
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2412
2722
_IRQL_requires_max_(DISPATCH_LEVEL)
2413
2723
WDFAPI
2414
2724
PVOID
2725
+
STDCALL
2415
2726
WDFEXPORT(WdfDmaTransactionWdmGetTransferContext)(
2416
2727
_In_
2417
2728
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2422
2733
_IRQL_requires_max_(DISPATCH_LEVEL)
2423
2734
WDFAPI
2424
2735
VOID
2736
+
STDCALL
2425
2737
WDFEXPORT(WdfDmaTransactionStopSystemTransfer)(
2426
2738
_In_
2427
2739
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2433
2745
_IRQL_requires_max_(DISPATCH_LEVEL)
2434
2746
WDFAPI
2435
2747
NTSTATUS
2748
+
STDCALL
2436
2749
WDFEXPORT(WdfDpcCreate)(
2437
2750
_In_
2438
2751
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2447
2760
_IRQL_requires_max_(HIGH_LEVEL)
2448
2761
WDFAPI
2449
2762
BOOLEAN
2763
+
STDCALL
2450
2764
WDFEXPORT(WdfDpcEnqueue)(
2451
2765
_In_
2452
2766
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2458
2772
_When_(Wait == __false, _IRQL_requires_max_(HIGH_LEVEL))
2459
2773
WDFAPI
2460
2774
BOOLEAN
2775
+
STDCALL
2461
2776
WDFEXPORT(WdfDpcCancel)(
2462
2777
_In_
2463
2778
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2470
2785
_IRQL_requires_max_(HIGH_LEVEL)
2471
2786
WDFAPI
2472
2787
WDFOBJECT
2788
+
STDCALL
2473
2789
WDFEXPORT(WdfDpcGetParentObject)(
2474
2790
_In_
2475
2791
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2480
2796
_IRQL_requires_max_(HIGH_LEVEL)
2481
2797
WDFAPI
2482
2798
PKDPC
2799
+
STDCALL
2483
2800
WDFEXPORT(WdfDpcWdmGetDpc)(
2484
2801
_In_
2485
2802
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2491
2808
_IRQL_requires_max_(PASSIVE_LEVEL)
2492
2809
WDFAPI
2493
2810
NTSTATUS
2811
+
STDCALL
2494
2812
WDFEXPORT(WdfDriverCreate)(
2495
2813
_In_
2496
2814
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2509
2827
_IRQL_requires_max_(PASSIVE_LEVEL)
2510
2828
WDFAPI
2511
2829
PWSTR
2830
+
STDCALL
2512
2831
WDFEXPORT(WdfDriverGetRegistryPath)(
2513
2832
_In_
2514
2833
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2519
2838
_IRQL_requires_max_(DISPATCH_LEVEL)
2520
2839
WDFAPI
2521
2840
PDRIVER_OBJECT
2841
+
STDCALL
2522
2842
WDFEXPORT(WdfDriverWdmGetDriverObject)(
2523
2843
_In_
2524
2844
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2530
2850
_IRQL_requires_max_(PASSIVE_LEVEL)
2531
2851
WDFAPI
2532
2852
NTSTATUS
2853
+
STDCALL
2533
2854
WDFEXPORT(WdfDriverOpenParametersRegistryKey)(
2534
2855
_In_
2535
2856
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2546
2867
_IRQL_requires_max_(DISPATCH_LEVEL)
2547
2868
WDFAPI
2548
2869
WDFDRIVER
2870
+
STDCALL
2549
2871
WDFEXPORT(WdfWdmDriverGetWdfDriverHandle)(
2550
2872
_In_
2551
2873
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2557
2879
_IRQL_requires_max_(PASSIVE_LEVEL)
2558
2880
WDFAPI
2559
2881
NTSTATUS
2882
+
STDCALL
2560
2883
WDFEXPORT(WdfDriverRegisterTraceInfo)(
2561
2884
_In_
2562
2885
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2572
2895
_IRQL_requires_max_(PASSIVE_LEVEL)
2573
2896
WDFAPI
2574
2897
NTSTATUS
2898
+
STDCALL
2575
2899
WDFEXPORT(WdfDriverRetrieveVersionString)(
2576
2900
_In_
2577
2901
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2585
2909
_IRQL_requires_max_(PASSIVE_LEVEL)
2586
2910
WDFAPI
2587
2911
BOOLEAN
2912
+
STDCALL
2588
2913
WDFEXPORT(WdfDriverIsVersionAvailable)(
2589
2914
_In_
2590
2915
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2597
2922
_IRQL_requires_max_(DISPATCH_LEVEL)
2598
2923
WDFAPI
2599
2924
PDEVICE_OBJECT
2925
+
STDCALL
2600
2926
WDFEXPORT(WdfFdoInitWdmGetPhysicalDevice)(
2601
2927
_In_
2602
2928
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2608
2934
_IRQL_requires_max_(PASSIVE_LEVEL)
2609
2935
WDFAPI
2610
2936
NTSTATUS
2937
+
STDCALL
2611
2938
WDFEXPORT(WdfFdoInitOpenRegistryKey)(
2612
2939
_In_
2613
2940
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2627
2954
_IRQL_requires_max_(PASSIVE_LEVEL)
2628
2955
WDFAPI
2629
2956
NTSTATUS
2957
+
STDCALL
2630
2958
WDFEXPORT(WdfFdoInitQueryProperty)(
2631
2959
_In_
2632
2960
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2646
2974
_IRQL_requires_max_(PASSIVE_LEVEL)
2647
2975
WDFAPI
2648
2976
NTSTATUS
2977
+
STDCALL
2649
2978
WDFEXPORT(WdfFdoInitAllocAndQueryProperty)(
2650
2979
_In_
2651
2980
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2666
2995
_IRQL_requires_max_(PASSIVE_LEVEL)
2667
2996
WDFAPI
2668
2997
NTSTATUS
2998
+
STDCALL
2669
2999
WDFEXPORT(WdfFdoInitQueryPropertyEx)(
2670
3000
_In_
2671
3001
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2687
3017
_IRQL_requires_max_(PASSIVE_LEVEL)
2688
3018
WDFAPI
2689
3019
NTSTATUS
3020
+
STDCALL
2690
3021
WDFEXPORT(WdfFdoInitAllocAndQueryPropertyEx)(
2691
3022
_In_
2692
3023
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2708
3039
_IRQL_requires_max_(PASSIVE_LEVEL)
2709
3040
WDFAPI
2710
3041
VOID
3042
+
STDCALL
2711
3043
WDFEXPORT(WdfFdoInitSetEventCallbacks)(
2712
3044
_In_
2713
3045
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2720
3052
_IRQL_requires_max_(PASSIVE_LEVEL)
2721
3053
WDFAPI
2722
3054
VOID
3055
+
STDCALL
2723
3056
WDFEXPORT(WdfFdoInitSetFilter)(
2724
3057
_In_
2725
3058
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2730
3063
_IRQL_requires_max_(PASSIVE_LEVEL)
2731
3064
WDFAPI
2732
3065
VOID
3066
+
STDCALL
2733
3067
WDFEXPORT(WdfFdoInitSetDefaultChildListConfig)(
2734
3068
_In_
2735
3069
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2745
3079
_IRQL_requires_max_(PASSIVE_LEVEL)
2746
3080
WDFAPI
2747
3081
NTSTATUS
3082
+
STDCALL
2748
3083
WDFEXPORT(WdfFdoQueryForInterface)(
2749
3084
_In_
2750
3085
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2765
3100
_IRQL_requires_max_(DISPATCH_LEVEL)
2766
3101
WDFAPI
2767
3102
WDFCHILDLIST
3103
+
STDCALL
2768
3104
WDFEXPORT(WdfFdoGetDefaultChildList)(
2769
3105
_In_
2770
3106
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2776
3112
_IRQL_requires_max_(DISPATCH_LEVEL)
2777
3113
WDFAPI
2778
3114
NTSTATUS
3115
+
STDCALL
2779
3116
WDFEXPORT(WdfFdoAddStaticChild)(
2780
3117
_In_
2781
3118
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2788
3125
_IRQL_requires_max_(DISPATCH_LEVEL)
2789
3126
WDFAPI
2790
3127
VOID
3128
+
STDCALL
2791
3129
WDFEXPORT(WdfFdoLockStaticChildListForIteration)(
2792
3130
_In_
2793
3131
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2799
3137
_IRQL_requires_max_(DISPATCH_LEVEL)
2800
3138
WDFAPI
2801
3139
WDFDEVICE
3140
+
STDCALL
2802
3141
WDFEXPORT(WdfFdoRetrieveNextStaticChild)(
2803
3142
_In_
2804
3143
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2813
3152
_IRQL_requires_max_(DISPATCH_LEVEL)
2814
3153
WDFAPI
2815
3154
VOID
3155
+
STDCALL
2816
3156
WDFEXPORT(WdfFdoUnlockStaticChildListFromIteration)(
2817
3157
_In_
2818
3158
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2823
3163
_IRQL_requires_max_(PASSIVE_LEVEL)
2824
3164
WDFAPI
2825
3165
PUNICODE_STRING
3166
+
STDCALL
2826
3167
WDFEXPORT(WdfFileObjectGetFileName)(
2827
3168
_In_
2828
3169
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2833
3174
_IRQL_requires_max_(DISPATCH_LEVEL)
2834
3175
WDFAPI
2835
3176
ULONG
3177
+
STDCALL
2836
3178
WDFEXPORT(WdfFileObjectGetFlags)(
2837
3179
_In_
2838
3180
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2843
3185
_IRQL_requires_max_(DISPATCH_LEVEL)
2844
3186
WDFAPI
2845
3187
WDFDEVICE
3188
+
STDCALL
2846
3189
WDFEXPORT(WdfFileObjectGetDevice)(
2847
3190
_In_
2848
3191
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2853
3196
_IRQL_requires_max_(DISPATCH_LEVEL)
2854
3197
WDFAPI
2855
3198
PFILE_OBJECT
3199
+
STDCALL
2856
3200
WDFEXPORT(WdfFileObjectWdmGetFileObject)(
2857
3201
_In_
2858
3202
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2864
3208
_IRQL_requires_max_(DISPATCH_LEVEL)
2865
3209
WDFAPI
2866
3210
NTSTATUS
3211
+
STDCALL
2867
3212
WDFEXPORT(WdfInterruptCreate)(
2868
3213
_In_
2869
3214
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2879
3224
2880
3225
WDFAPI
2881
3226
BOOLEAN
3227
+
STDCALL
2882
3228
WDFEXPORT(WdfInterruptQueueDpcForIsr)(
2883
3229
_In_
2884
3230
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2888
3234
2889
3235
WDFAPI
2890
3236
BOOLEAN
3237
+
STDCALL
2891
3238
WDFEXPORT(WdfInterruptQueueWorkItemForIsr)(
2892
3239
_In_
2893
3240
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2898
3245
_IRQL_requires_max_(DISPATCH_LEVEL)
2899
3246
WDFAPI
2900
3247
BOOLEAN
3248
+
STDCALL
2901
3249
WDFEXPORT(WdfInterruptSynchronize)(
2902
3250
_In_
2903
3251
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2912
3260
_IRQL_requires_max_(DISPATCH_LEVEL + 1)
2913
3261
WDFAPI
2914
3262
VOID
3263
+
STDCALL
2915
3264
WDFEXPORT(WdfInterruptAcquireLock)(
2916
3265
_In_
2917
3266
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2924
3273
_IRQL_requires_max_(DISPATCH_LEVEL + 1)
2925
3274
WDFAPI
2926
3275
VOID
3276
+
STDCALL
2927
3277
WDFEXPORT(WdfInterruptReleaseLock)(
2928
3278
_In_
2929
3279
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2936
3286
_IRQL_requires_max_(PASSIVE_LEVEL)
2937
3287
WDFAPI
2938
3288
VOID
3289
+
STDCALL
2939
3290
WDFEXPORT(WdfInterruptEnable)(
2940
3291
_In_
2941
3292
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2946
3297
_IRQL_requires_max_(PASSIVE_LEVEL)
2947
3298
WDFAPI
2948
3299
VOID
3300
+
STDCALL
2949
3301
WDFEXPORT(WdfInterruptDisable)(
2950
3302
_In_
2951
3303
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2956
3308
_Must_inspect_result_
2957
3309
WDFAPI
2958
3310
PKINTERRUPT
3311
+
STDCALL
2959
3312
WDFEXPORT(WdfInterruptWdmGetInterrupt)(
2960
3313
_In_
2961
3314
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2966
3319
_IRQL_requires_max_(DISPATCH_LEVEL)
2967
3320
WDFAPI
2968
3321
VOID
3322
+
STDCALL
2969
3323
WDFEXPORT(WdfInterruptGetInfo)(
2970
3324
_In_
2971
3325
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2978
3332
_IRQL_requires_max_(DISPATCH_LEVEL)
2979
3333
WDFAPI
2980
3334
VOID
3335
+
STDCALL
2981
3336
WDFEXPORT(WdfInterruptSetPolicy)(
2982
3337
_In_
2983
3338
PWDF_DRIVER_GLOBALS DriverGlobals,
···
2994
3349
_IRQL_requires_max_(DISPATCH_LEVEL)
2995
3350
WDFAPI
2996
3351
VOID
3352
+
STDCALL
2997
3353
WDFEXPORT(WdfInterruptSetExtendedPolicy)(
2998
3354
_In_
2999
3355
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3005
3361
3006
3362
WDFAPI
3007
3363
WDFDEVICE
3364
+
STDCALL
3008
3365
WDFEXPORT(WdfInterruptGetDevice)(
3009
3366
_In_
3010
3367
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3017
3374
_IRQL_requires_max_(PASSIVE_LEVEL)
3018
3375
WDFAPI
3019
3376
BOOLEAN
3377
+
STDCALL
3020
3378
WDFEXPORT(WdfInterruptTryToAcquireLock)(
3021
3379
_In_
3022
3380
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3029
3387
_IRQL_requires_max_(DISPATCH_LEVEL)
3030
3388
WDFAPI
3031
3389
VOID
3390
+
STDCALL
3032
3391
WDFEXPORT(WdfInterruptReportActive)(
3033
3392
_In_
3034
3393
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3039
3398
_IRQL_requires_max_(DISPATCH_LEVEL)
3040
3399
WDFAPI
3041
3400
VOID
3401
+
STDCALL
3042
3402
WDFEXPORT(WdfInterruptReportInactive)(
3043
3403
_In_
3044
3404
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3050
3410
_IRQL_requires_max_(DISPATCH_LEVEL)
3051
3411
WDFAPI
3052
3412
NTSTATUS
3413
+
STDCALL
3053
3414
WDFEXPORT(WdfIoQueueCreate)(
3054
3415
_In_
3055
3416
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3066
3427
_IRQL_requires_max_(DISPATCH_LEVEL)
3067
3428
WDFAPI
3068
3429
WDF_IO_QUEUE_STATE
3430
+
STDCALL
3069
3431
WDFEXPORT(WdfIoQueueGetState)(
3070
3432
_In_
3071
3433
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3080
3442
_IRQL_requires_max_(DISPATCH_LEVEL)
3081
3443
WDFAPI
3082
3444
VOID
3445
+
STDCALL
3083
3446
WDFEXPORT(WdfIoQueueStart)(
3084
3447
_In_
3085
3448
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3090
3453
_IRQL_requires_max_(DISPATCH_LEVEL)
3091
3454
WDFAPI
3092
3455
VOID
3456
+
STDCALL
3093
3457
WDFEXPORT(WdfIoQueueStop)(
3094
3458
_In_
3095
3459
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3106
3470
_IRQL_requires_max_(PASSIVE_LEVEL)
3107
3471
WDFAPI
3108
3472
VOID
3473
+
STDCALL
3109
3474
WDFEXPORT(WdfIoQueueStopSynchronously)(
3110
3475
_In_
3111
3476
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3116
3481
_IRQL_requires_max_(DISPATCH_LEVEL)
3117
3482
WDFAPI
3118
3483
WDFDEVICE
3484
+
STDCALL
3119
3485
WDFEXPORT(WdfIoQueueGetDevice)(
3120
3486
_In_
3121
3487
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3127
3493
_IRQL_requires_max_(DISPATCH_LEVEL)
3128
3494
WDFAPI
3129
3495
NTSTATUS
3496
+
STDCALL
3130
3497
WDFEXPORT(WdfIoQueueRetrieveNextRequest)(
3131
3498
_In_
3132
3499
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3140
3507
_IRQL_requires_max_(DISPATCH_LEVEL)
3141
3508
WDFAPI
3142
3509
NTSTATUS
3510
+
STDCALL
3143
3511
WDFEXPORT(WdfIoQueueRetrieveRequestByFileObject)(
3144
3512
_In_
3145
3513
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3155
3523
_IRQL_requires_max_(DISPATCH_LEVEL)
3156
3524
WDFAPI
3157
3525
NTSTATUS
3526
+
STDCALL
3158
3527
WDFEXPORT(WdfIoQueueFindRequest)(
3159
3528
_In_
3160
3529
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3174
3543
_IRQL_requires_max_(DISPATCH_LEVEL)
3175
3544
WDFAPI
3176
3545
NTSTATUS
3546
+
STDCALL
3177
3547
WDFEXPORT(WdfIoQueueRetrieveFoundRequest)(
3178
3548
_In_
3179
3549
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3188
3558
_IRQL_requires_max_(PASSIVE_LEVEL)
3189
3559
WDFAPI
3190
3560
VOID
3561
+
STDCALL
3191
3562
WDFEXPORT(WdfIoQueueDrainSynchronously)(
3192
3563
_In_
3193
3564
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3198
3569
_IRQL_requires_max_(DISPATCH_LEVEL)
3199
3570
WDFAPI
3200
3571
VOID
3572
+
STDCALL
3201
3573
WDFEXPORT(WdfIoQueueDrain)(
3202
3574
_In_
3203
3575
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3214
3586
_IRQL_requires_max_(PASSIVE_LEVEL)
3215
3587
WDFAPI
3216
3588
VOID
3589
+
STDCALL
3217
3590
WDFEXPORT(WdfIoQueuePurgeSynchronously)(
3218
3591
_In_
3219
3592
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3224
3597
_IRQL_requires_max_(DISPATCH_LEVEL)
3225
3598
WDFAPI
3226
3599
VOID
3600
+
STDCALL
3227
3601
WDFEXPORT(WdfIoQueuePurge)(
3228
3602
_In_
3229
3603
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3241
3615
_IRQL_requires_max_(DISPATCH_LEVEL)
3242
3616
WDFAPI
3243
3617
NTSTATUS
3618
+
STDCALL
3244
3619
WDFEXPORT(WdfIoQueueReadyNotify)(
3245
3620
_In_
3246
3621
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3256
3631
_IRQL_requires_max_(PASSIVE_LEVEL)
3257
3632
WDFAPI
3258
3633
NTSTATUS
3634
+
STDCALL
3259
3635
WDFEXPORT(WdfIoQueueAssignForwardProgressPolicy)(
3260
3636
_In_
3261
3637
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3268
3644
_IRQL_requires_max_(DISPATCH_LEVEL)
3269
3645
WDFAPI
3270
3646
VOID
3647
+
STDCALL
3271
3648
WDFEXPORT(WdfIoQueueStopAndPurge)(
3272
3649
_In_
3273
3650
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3284
3661
_IRQL_requires_max_(PASSIVE_LEVEL)
3285
3662
WDFAPI
3286
3663
VOID
3664
+
STDCALL
3287
3665
WDFEXPORT(WdfIoQueueStopAndPurgeSynchronously)(
3288
3666
_In_
3289
3667
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3295
3673
_IRQL_requires_max_(PASSIVE_LEVEL)
3296
3674
WDFAPI
3297
3675
NTSTATUS
3676
+
STDCALL
3298
3677
WDFEXPORT(WdfIoTargetCreate)(
3299
3678
_In_
3300
3679
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3310
3689
_IRQL_requires_max_(PASSIVE_LEVEL)
3311
3690
WDFAPI
3312
3691
NTSTATUS
3692
+
STDCALL
3313
3693
WDFEXPORT(WdfIoTargetOpen)(
3314
3694
_In_
3315
3695
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3322
3702
_IRQL_requires_max_(PASSIVE_LEVEL)
3323
3703
WDFAPI
3324
3704
VOID
3705
+
STDCALL
3325
3706
WDFEXPORT(WdfIoTargetCloseForQueryRemove)(
3326
3707
_In_
3327
3708
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3332
3713
_IRQL_requires_max_(PASSIVE_LEVEL)
3333
3714
WDFAPI
3334
3715
VOID
3716
+
STDCALL
3335
3717
WDFEXPORT(WdfIoTargetClose)(
3336
3718
_In_
3337
3719
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3343
3725
_IRQL_requires_max_(DISPATCH_LEVEL)
3344
3726
WDFAPI
3345
3727
NTSTATUS
3728
+
STDCALL
3346
3729
WDFEXPORT(WdfIoTargetStart)(
3347
3730
_In_
3348
3731
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3354
3737
_When_(Action == 0 || Action == 1 || Action == 2, _IRQL_requires_max_(PASSIVE_LEVEL))
3355
3738
WDFAPI
3356
3739
VOID
3740
+
STDCALL
3357
3741
WDFEXPORT(WdfIoTargetStop)(
3358
3742
_In_
3359
3743
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3368
3752
_When_(Action == 0 || Action == 1, _IRQL_requires_max_(PASSIVE_LEVEL))
3369
3753
WDFAPI
3370
3754
VOID
3755
+
STDCALL
3371
3756
WDFEXPORT(WdfIoTargetPurge)(
3372
3757
_In_
3373
3758
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3381
3766
_IRQL_requires_max_(DISPATCH_LEVEL)
3382
3767
WDFAPI
3383
3768
WDF_IO_TARGET_STATE
3769
+
STDCALL
3384
3770
WDFEXPORT(WdfIoTargetGetState)(
3385
3771
_In_
3386
3772
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3391
3777
_IRQL_requires_max_(DISPATCH_LEVEL)
3392
3778
WDFAPI
3393
3779
WDFDEVICE
3780
+
STDCALL
3394
3781
WDFEXPORT(WdfIoTargetGetDevice)(
3395
3782
_In_
3396
3783
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3402
3789
_IRQL_requires_max_(PASSIVE_LEVEL)
3403
3790
WDFAPI
3404
3791
NTSTATUS
3792
+
STDCALL
3405
3793
WDFEXPORT(WdfIoTargetQueryTargetProperty)(
3406
3794
_In_
3407
3795
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3422
3810
_IRQL_requires_max_(PASSIVE_LEVEL)
3423
3811
WDFAPI
3424
3812
NTSTATUS
3813
+
STDCALL
3425
3814
WDFEXPORT(WdfIoTargetAllocAndQueryTargetProperty)(
3426
3815
_In_
3427
3816
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3442
3831
_IRQL_requires_max_(PASSIVE_LEVEL)
3443
3832
WDFAPI
3444
3833
NTSTATUS
3834
+
STDCALL
3445
3835
WDFEXPORT(WdfIoTargetQueryForInterface)(
3446
3836
_In_
3447
3837
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3462
3852
_IRQL_requires_max_(DISPATCH_LEVEL)
3463
3853
WDFAPI
3464
3854
PDEVICE_OBJECT
3855
+
STDCALL
3465
3856
WDFEXPORT(WdfIoTargetWdmGetTargetDeviceObject)(
3466
3857
_In_
3467
3858
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3472
3863
_IRQL_requires_max_(DISPATCH_LEVEL)
3473
3864
WDFAPI
3474
3865
PDEVICE_OBJECT
3866
+
STDCALL
3475
3867
WDFEXPORT(WdfIoTargetWdmGetTargetPhysicalDevice)(
3476
3868
_In_
3477
3869
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3482
3874
_IRQL_requires_max_(DISPATCH_LEVEL)
3483
3875
WDFAPI
3484
3876
PFILE_OBJECT
3877
+
STDCALL
3485
3878
WDFEXPORT(WdfIoTargetWdmGetTargetFileObject)(
3486
3879
_In_
3487
3880
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3492
3885
_IRQL_requires_max_(DISPATCH_LEVEL)
3493
3886
WDFAPI
3494
3887
HANDLE
3888
+
STDCALL
3495
3889
WDFEXPORT(WdfIoTargetWdmGetTargetFileHandle)(
3496
3890
_In_
3497
3891
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3503
3897
_IRQL_requires_max_(PASSIVE_LEVEL)
3504
3898
WDFAPI
3505
3899
NTSTATUS
3900
+
STDCALL
3506
3901
WDFEXPORT(WdfIoTargetSendReadSynchronously)(
3507
3902
_In_
3508
3903
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3524
3919
_IRQL_requires_max_(DISPATCH_LEVEL)
3525
3920
WDFAPI
3526
3921
NTSTATUS
3922
+
STDCALL
3527
3923
WDFEXPORT(WdfIoTargetFormatRequestForRead)(
3528
3924
_In_
3529
3925
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3543
3939
_IRQL_requires_max_(PASSIVE_LEVEL)
3544
3940
WDFAPI
3545
3941
NTSTATUS
3942
+
STDCALL
3546
3943
WDFEXPORT(WdfIoTargetSendWriteSynchronously)(
3547
3944
_In_
3548
3945
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3564
3961
_IRQL_requires_max_(DISPATCH_LEVEL)
3565
3962
WDFAPI
3566
3963
NTSTATUS
3964
+
STDCALL
3567
3965
WDFEXPORT(WdfIoTargetFormatRequestForWrite)(
3568
3966
_In_
3569
3967
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3583
3981
_IRQL_requires_max_(PASSIVE_LEVEL)
3584
3982
WDFAPI
3585
3983
NTSTATUS
3984
+
STDCALL
3586
3985
WDFEXPORT(WdfIoTargetSendIoctlSynchronously)(
3587
3986
_In_
3588
3987
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3606
4005
_IRQL_requires_max_(DISPATCH_LEVEL)
3607
4006
WDFAPI
3608
4007
NTSTATUS
4008
+
STDCALL
3609
4009
WDFEXPORT(WdfIoTargetFormatRequestForIoctl)(
3610
4010
_In_
3611
4011
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3629
4029
_IRQL_requires_max_(PASSIVE_LEVEL)
3630
4030
WDFAPI
3631
4031
NTSTATUS
4032
+
STDCALL
3632
4033
WDFEXPORT(WdfIoTargetSendInternalIoctlSynchronously)(
3633
4034
_In_
3634
4035
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3652
4053
_IRQL_requires_max_(DISPATCH_LEVEL)
3653
4054
WDFAPI
3654
4055
NTSTATUS
4056
+
STDCALL
3655
4057
WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctl)(
3656
4058
_In_
3657
4059
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3675
4077
_IRQL_requires_max_(PASSIVE_LEVEL)
3676
4078
WDFAPI
3677
4079
NTSTATUS
4080
+
STDCALL
3678
4081
WDFEXPORT(WdfIoTargetSendInternalIoctlOthersSynchronously)(
3679
4082
_In_
3680
4083
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3700
4103
_IRQL_requires_max_(DISPATCH_LEVEL)
3701
4104
WDFAPI
3702
4105
NTSTATUS
4106
+
STDCALL
3703
4107
WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctlOthers)(
3704
4108
_In_
3705
4109
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3726
4130
_IRQL_requires_max_(DISPATCH_LEVEL)
3727
4131
WDFAPI
3728
4132
NTSTATUS
4133
+
STDCALL
3729
4134
WDFEXPORT(WdfIoTargetSelfAssignDefaultIoQueue)(
3730
4135
_In_
3731
4136
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3740
4145
_When_(PoolType == 0 || PoolType == 256, _IRQL_requires_max_(DISPATCH_LEVEL))
3741
4146
WDFAPI
3742
4147
NTSTATUS
4148
+
STDCALL
3743
4149
WDFEXPORT(WdfMemoryCreate)(
3744
4150
_In_
3745
4151
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3763
4169
_IRQL_requires_max_(DISPATCH_LEVEL)
3764
4170
WDFAPI
3765
4171
NTSTATUS
4172
+
STDCALL
3766
4173
WDFEXPORT(WdfMemoryCreatePreallocated)(
3767
4174
_In_
3768
4175
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3780
4187
_IRQL_requires_max_(DISPATCH_LEVEL)
3781
4188
WDFAPI
3782
4189
PVOID
4190
+
STDCALL
3783
4191
WDFEXPORT(WdfMemoryGetBuffer)(
3784
4192
_In_
3785
4193
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3793
4201
_IRQL_requires_max_(DISPATCH_LEVEL)
3794
4202
WDFAPI
3795
4203
NTSTATUS
4204
+
STDCALL
3796
4205
WDFEXPORT(WdfMemoryAssignBuffer)(
3797
4206
_In_
3798
4207
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3809
4218
_IRQL_requires_max_(DISPATCH_LEVEL)
3810
4219
WDFAPI
3811
4220
NTSTATUS
4221
+
STDCALL
3812
4222
WDFEXPORT(WdfMemoryCopyToBuffer)(
3813
4223
_In_
3814
4224
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3827
4237
_IRQL_requires_max_(DISPATCH_LEVEL)
3828
4238
WDFAPI
3829
4239
NTSTATUS
4240
+
STDCALL
3830
4241
WDFEXPORT(WdfMemoryCopyFromBuffer)(
3831
4242
_In_
3832
4243
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3846
4257
_When_(PoolType == 0 || PoolType == 256, _IRQL_requires_max_(DISPATCH_LEVEL))
3847
4258
WDFAPI
3848
4259
NTSTATUS
4260
+
STDCALL
3849
4261
WDFEXPORT(WdfLookasideListCreate)(
3850
4262
_In_
3851
4263
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3869
4281
_IRQL_requires_max_(DISPATCH_LEVEL)
3870
4282
WDFAPI
3871
4283
NTSTATUS
4284
+
STDCALL
3872
4285
WDFEXPORT(WdfMemoryCreateFromLookaside)(
3873
4286
_In_
3874
4287
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3882
4295
_IRQL_requires_max_(PASSIVE_LEVEL)
3883
4296
WDFAPI
3884
4297
NTSTATUS
4298
+
STDCALL
3885
4299
WDFEXPORT(WdfDeviceMiniportCreate)(
3886
4300
_In_
3887
4301
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3901
4315
3902
4316
WDFAPI
3903
4317
VOID
4318
+
STDCALL
3904
4319
WDFEXPORT(WdfDriverMiniportUnload)(
3905
4320
_In_
3906
4321
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3922
4337
3923
4338
WDFAPI
3924
4339
NTSTATUS
4340
+
STDCALL
3925
4341
WDFEXPORT(WdfObjectAllocateContext)(
3926
4342
_In_
3927
4343
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3945
4361
3946
4362
WDFAPI
3947
4363
VOID
4364
+
STDCALL
3948
4365
WDFEXPORT(WdfObjectReferenceActual)(
3949
4366
_In_
3950
4367
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3960
4377
3961
4378
WDFAPI
3962
4379
VOID
4380
+
STDCALL
3963
4381
WDFEXPORT(WdfObjectDereferenceActual)(
3964
4382
_In_
3965
4383
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3977
4395
_IRQL_requires_max_(DISPATCH_LEVEL)
3978
4396
WDFAPI
3979
4397
NTSTATUS
4398
+
STDCALL
3980
4399
WDFEXPORT(WdfObjectCreate)(
3981
4400
_In_
3982
4401
PWDF_DRIVER_GLOBALS DriverGlobals,
···
3989
4408
_IRQL_requires_max_(DISPATCH_LEVEL)
3990
4409
WDFAPI
3991
4410
VOID
4411
+
STDCALL
3992
4412
WDFEXPORT(WdfObjectDelete)(
3993
4413
_In_
3994
4414
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4000
4420
_IRQL_requires_max_(DISPATCH_LEVEL)
4001
4421
WDFAPI
4002
4422
NTSTATUS
4423
+
STDCALL
4003
4424
WDFEXPORT(WdfObjectQuery)(
4004
4425
_In_
4005
4426
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4017
4438
_IRQL_requires_max_(PASSIVE_LEVEL)
4018
4439
WDFAPI
4019
4440
PWDFDEVICE_INIT
4441
+
STDCALL
4020
4442
WDFEXPORT(WdfPdoInitAllocate)(
4021
4443
_In_
4022
4444
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4027
4449
_IRQL_requires_max_(PASSIVE_LEVEL)
4028
4450
WDFAPI
4029
4451
VOID
4452
+
STDCALL
4030
4453
WDFEXPORT(WdfPdoInitSetEventCallbacks)(
4031
4454
_In_
4032
4455
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4040
4463
_IRQL_requires_max_(PASSIVE_LEVEL)
4041
4464
WDFAPI
4042
4465
NTSTATUS
4466
+
STDCALL
4043
4467
WDFEXPORT(WdfPdoInitAssignDeviceID)(
4044
4468
_In_
4045
4469
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4053
4477
_IRQL_requires_max_(PASSIVE_LEVEL)
4054
4478
WDFAPI
4055
4479
NTSTATUS
4480
+
STDCALL
4056
4481
WDFEXPORT(WdfPdoInitAssignInstanceID)(
4057
4482
_In_
4058
4483
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4066
4491
_IRQL_requires_max_(PASSIVE_LEVEL)
4067
4492
WDFAPI
4068
4493
NTSTATUS
4494
+
STDCALL
4069
4495
WDFEXPORT(WdfPdoInitAddHardwareID)(
4070
4496
_In_
4071
4497
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4079
4505
_IRQL_requires_max_(PASSIVE_LEVEL)
4080
4506
WDFAPI
4081
4507
NTSTATUS
4508
+
STDCALL
4082
4509
WDFEXPORT(WdfPdoInitAddCompatibleID)(
4083
4510
_In_
4084
4511
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4092
4519
_IRQL_requires_max_(PASSIVE_LEVEL)
4093
4520
WDFAPI
4094
4521
NTSTATUS
4522
+
STDCALL
4095
4523
WDFEXPORT(WdfPdoInitAssignContainerID)(
4096
4524
_In_
4097
4525
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4105
4533
_IRQL_requires_max_(PASSIVE_LEVEL)
4106
4534
WDFAPI
4107
4535
NTSTATUS
4536
+
STDCALL
4108
4537
WDFEXPORT(WdfPdoInitAddDeviceText)(
4109
4538
_In_
4110
4539
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4121
4550
_IRQL_requires_max_(PASSIVE_LEVEL)
4122
4551
WDFAPI
4123
4552
VOID
4553
+
STDCALL
4124
4554
WDFEXPORT(WdfPdoInitSetDefaultLocale)(
4125
4555
_In_
4126
4556
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4134
4564
_IRQL_requires_max_(PASSIVE_LEVEL)
4135
4565
WDFAPI
4136
4566
NTSTATUS
4567
+
STDCALL
4137
4568
WDFEXPORT(WdfPdoInitAssignRawDevice)(
4138
4569
_In_
4139
4570
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4146
4577
_IRQL_requires_max_(PASSIVE_LEVEL)
4147
4578
WDFAPI
4148
4579
VOID
4580
+
STDCALL
4149
4581
WDFEXPORT(WdfPdoInitAllowForwardingRequestToParent)(
4150
4582
_In_
4151
4583
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4157
4589
_IRQL_requires_max_(DISPATCH_LEVEL)
4158
4590
WDFAPI
4159
4591
NTSTATUS
4592
+
STDCALL
4160
4593
WDFEXPORT(WdfPdoMarkMissing)(
4161
4594
_In_
4162
4595
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4167
4600
_IRQL_requires_max_(DISPATCH_LEVEL)
4168
4601
WDFAPI
4169
4602
VOID
4603
+
STDCALL
4170
4604
WDFEXPORT(WdfPdoRequestEject)(
4171
4605
_In_
4172
4606
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4177
4611
_IRQL_requires_max_(DISPATCH_LEVEL)
4178
4612
WDFAPI
4179
4613
WDFDEVICE
4614
+
STDCALL
4180
4615
WDFEXPORT(WdfPdoGetParent)(
4181
4616
_In_
4182
4617
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4188
4623
_IRQL_requires_max_(DISPATCH_LEVEL)
4189
4624
WDFAPI
4190
4625
NTSTATUS
4626
+
STDCALL
4191
4627
WDFEXPORT(WdfPdoRetrieveIdentificationDescription)(
4192
4628
_In_
4193
4629
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4201
4637
_IRQL_requires_max_(DISPATCH_LEVEL)
4202
4638
WDFAPI
4203
4639
NTSTATUS
4640
+
STDCALL
4204
4641
WDFEXPORT(WdfPdoRetrieveAddressDescription)(
4205
4642
_In_
4206
4643
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4214
4651
_IRQL_requires_max_(DISPATCH_LEVEL)
4215
4652
WDFAPI
4216
4653
NTSTATUS
4654
+
STDCALL
4217
4655
WDFEXPORT(WdfPdoUpdateAddressDescription)(
4218
4656
_In_
4219
4657
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4227
4665
_IRQL_requires_max_(DISPATCH_LEVEL)
4228
4666
WDFAPI
4229
4667
NTSTATUS
4668
+
STDCALL
4230
4669
WDFEXPORT(WdfPdoAddEjectionRelationsPhysicalDevice)(
4231
4670
_In_
4232
4671
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4239
4678
_IRQL_requires_max_(DISPATCH_LEVEL)
4240
4679
WDFAPI
4241
4680
VOID
4681
+
STDCALL
4242
4682
WDFEXPORT(WdfPdoRemoveEjectionRelationsPhysicalDevice)(
4243
4683
_In_
4244
4684
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4251
4691
_IRQL_requires_max_(DISPATCH_LEVEL)
4252
4692
WDFAPI
4253
4693
VOID
4694
+
STDCALL
4254
4695
WDFEXPORT(WdfPdoClearEjectionRelationsDevices)(
4255
4696
_In_
4256
4697
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4262
4703
_IRQL_requires_max_(PASSIVE_LEVEL)
4263
4704
WDFAPI
4264
4705
NTSTATUS
4706
+
STDCALL
4265
4707
WDFEXPORT(WdfDeviceAddQueryInterface)(
4266
4708
_In_
4267
4709
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4275
4717
_IRQL_requires_max_(PASSIVE_LEVEL)
4276
4718
WDFAPI
4277
4719
NTSTATUS
4720
+
STDCALL
4278
4721
WDFEXPORT(WdfRegistryOpenKey)(
4279
4722
_In_
4280
4723
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4294
4737
_IRQL_requires_max_(PASSIVE_LEVEL)
4295
4738
WDFAPI
4296
4739
NTSTATUS
4740
+
STDCALL
4297
4741
WDFEXPORT(WdfRegistryCreateKey)(
4298
4742
_In_
4299
4743
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4316
4760
_IRQL_requires_max_(PASSIVE_LEVEL)
4317
4761
WDFAPI
4318
4762
VOID
4763
+
STDCALL
4319
4764
WDFEXPORT(WdfRegistryClose)(
4320
4765
_In_
4321
4766
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4326
4771
_IRQL_requires_max_(PASSIVE_LEVEL)
4327
4772
WDFAPI
4328
4773
HANDLE
4774
+
STDCALL
4329
4775
WDFEXPORT(WdfRegistryWdmGetHandle)(
4330
4776
_In_
4331
4777
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4337
4783
_IRQL_requires_max_(PASSIVE_LEVEL)
4338
4784
WDFAPI
4339
4785
NTSTATUS
4786
+
STDCALL
4340
4787
WDFEXPORT(WdfRegistryRemoveKey)(
4341
4788
_In_
4342
4789
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4348
4795
_IRQL_requires_max_(PASSIVE_LEVEL)
4349
4796
WDFAPI
4350
4797
NTSTATUS
4798
+
STDCALL
4351
4799
WDFEXPORT(WdfRegistryRemoveValue)(
4352
4800
_In_
4353
4801
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4361
4809
_IRQL_requires_max_(PASSIVE_LEVEL)
4362
4810
WDFAPI
4363
4811
NTSTATUS
4812
+
STDCALL
4364
4813
WDFEXPORT(WdfRegistryQueryValue)(
4365
4814
_In_
4366
4815
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4382
4831
_IRQL_requires_max_(PASSIVE_LEVEL)
4383
4832
WDFAPI
4384
4833
NTSTATUS
4834
+
STDCALL
4385
4835
WDFEXPORT(WdfRegistryQueryMemory)(
4386
4836
_In_
4387
4837
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4404
4854
_IRQL_requires_max_(PASSIVE_LEVEL)
4405
4855
WDFAPI
4406
4856
NTSTATUS
4857
+
STDCALL
4407
4858
WDFEXPORT(WdfRegistryQueryMultiString)(
4408
4859
_In_
4409
4860
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4421
4872
_IRQL_requires_max_(PASSIVE_LEVEL)
4422
4873
WDFAPI
4423
4874
NTSTATUS
4875
+
STDCALL
4424
4876
WDFEXPORT(WdfRegistryQueryUnicodeString)(
4425
4877
_In_
4426
4878
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4438
4890
_IRQL_requires_max_(PASSIVE_LEVEL)
4439
4891
WDFAPI
4440
4892
NTSTATUS
4893
+
STDCALL
4441
4894
WDFEXPORT(WdfRegistryQueryString)(
4442
4895
_In_
4443
4896
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4453
4906
_IRQL_requires_max_(PASSIVE_LEVEL)
4454
4907
WDFAPI
4455
4908
NTSTATUS
4909
+
STDCALL
4456
4910
WDFEXPORT(WdfRegistryQueryULong)(
4457
4911
_In_
4458
4912
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4468
4922
_IRQL_requires_max_(PASSIVE_LEVEL)
4469
4923
WDFAPI
4470
4924
NTSTATUS
4925
+
STDCALL
4471
4926
WDFEXPORT(WdfRegistryAssignValue)(
4472
4927
_In_
4473
4928
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4487
4942
_IRQL_requires_max_(PASSIVE_LEVEL)
4488
4943
WDFAPI
4489
4944
NTSTATUS
4945
+
STDCALL
4490
4946
WDFEXPORT(WdfRegistryAssignMemory)(
4491
4947
_In_
4492
4948
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4506
4962
_IRQL_requires_max_(PASSIVE_LEVEL)
4507
4963
WDFAPI
4508
4964
NTSTATUS
4965
+
STDCALL
4509
4966
WDFEXPORT(WdfRegistryAssignMultiString)(
4510
4967
_In_
4511
4968
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4521
4978
_IRQL_requires_max_(PASSIVE_LEVEL)
4522
4979
WDFAPI
4523
4980
NTSTATUS
4981
+
STDCALL
4524
4982
WDFEXPORT(WdfRegistryAssignUnicodeString)(
4525
4983
_In_
4526
4984
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4536
4994
_IRQL_requires_max_(PASSIVE_LEVEL)
4537
4995
WDFAPI
4538
4996
NTSTATUS
4997
+
STDCALL
4539
4998
WDFEXPORT(WdfRegistryAssignString)(
4540
4999
_In_
4541
5000
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4551
5010
_IRQL_requires_max_(PASSIVE_LEVEL)
4552
5011
WDFAPI
4553
5012
NTSTATUS
5013
+
STDCALL
4554
5014
WDFEXPORT(WdfRegistryAssignULong)(
4555
5015
_In_
4556
5016
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4566
5026
_IRQL_requires_max_(DISPATCH_LEVEL)
4567
5027
WDFAPI
4568
5028
NTSTATUS
5029
+
STDCALL
4569
5030
WDFEXPORT(WdfRequestCreate)(
4570
5031
_In_
4571
5032
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4581
5042
_IRQL_requires_max_(DISPATCH_LEVEL)
4582
5043
WDFAPI
4583
5044
NTSTATUS
5045
+
STDCALL
4584
5046
WDFEXPORT(WdfRequestCreateFromIrp)(
4585
5047
_In_
4586
5048
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4597
5059
_IRQL_requires_max_(DISPATCH_LEVEL)
4598
5060
WDFAPI
4599
5061
NTSTATUS
5062
+
STDCALL
4600
5063
WDFEXPORT(WdfRequestReuse)(
4601
5064
_In_
4602
5065
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4610
5073
_IRQL_requires_max_(DISPATCH_LEVEL)
4611
5074
WDFAPI
4612
5075
NTSTATUS
5076
+
STDCALL
4613
5077
WDFEXPORT(WdfRequestChangeTarget)(
4614
5078
_In_
4615
5079
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4622
5086
_IRQL_requires_max_(DISPATCH_LEVEL)
4623
5087
WDFAPI
4624
5088
VOID
5089
+
STDCALL
4625
5090
WDFEXPORT(WdfRequestFormatRequestUsingCurrentType)(
4626
5091
_In_
4627
5092
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4632
5097
_IRQL_requires_max_(DISPATCH_LEVEL)
4633
5098
WDFAPI
4634
5099
VOID
5100
+
STDCALL
4635
5101
WDFEXPORT(WdfRequestWdmFormatUsingStackLocation)(
4636
5102
_In_
4637
5103
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4645
5111
_When_(Options->Flags & WDF_REQUEST_SEND_OPTION_SYNCHRONOUS == 0, _Must_inspect_result_)
4646
5112
WDFAPI
4647
5113
BOOLEAN
5114
+
STDCALL
4648
5115
WDFEXPORT(WdfRequestSend)(
4649
5116
_In_
4650
5117
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4660
5127
_IRQL_requires_max_(DISPATCH_LEVEL)
4661
5128
WDFAPI
4662
5129
NTSTATUS
5130
+
STDCALL
4663
5131
WDFEXPORT(WdfRequestGetStatus)(
4664
5132
_In_
4665
5133
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4670
5138
_IRQL_requires_max_(DISPATCH_LEVEL)
4671
5139
WDFAPI
4672
5140
VOID
5141
+
STDCALL
4673
5142
WDFEXPORT(WdfRequestMarkCancelable)(
4674
5143
_In_
4675
5144
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4683
5152
_IRQL_requires_max_(DISPATCH_LEVEL)
4684
5153
WDFAPI
4685
5154
NTSTATUS
5155
+
STDCALL
4686
5156
WDFEXPORT(WdfRequestMarkCancelableEx)(
4687
5157
_In_
4688
5158
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4696
5166
_IRQL_requires_max_(DISPATCH_LEVEL)
4697
5167
WDFAPI
4698
5168
NTSTATUS
5169
+
STDCALL
4699
5170
WDFEXPORT(WdfRequestUnmarkCancelable)(
4700
5171
_In_
4701
5172
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4707
5178
_IRQL_requires_max_(DISPATCH_LEVEL)
4708
5179
WDFAPI
4709
5180
BOOLEAN
5181
+
STDCALL
4710
5182
WDFEXPORT(WdfRequestIsCanceled)(
4711
5183
_In_
4712
5184
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4717
5189
_IRQL_requires_max_(DISPATCH_LEVEL)
4718
5190
WDFAPI
4719
5191
BOOLEAN
5192
+
STDCALL
4720
5193
WDFEXPORT(WdfRequestCancelSentRequest)(
4721
5194
_In_
4722
5195
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4728
5201
_IRQL_requires_max_(APC_LEVEL)
4729
5202
WDFAPI
4730
5203
BOOLEAN
5204
+
STDCALL
4731
5205
WDFEXPORT(WdfRequestIsFrom32BitProcess)(
4732
5206
_In_
4733
5207
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4738
5212
_IRQL_requires_max_(DISPATCH_LEVEL)
4739
5213
WDFAPI
4740
5214
VOID
5215
+
STDCALL
4741
5216
WDFEXPORT(WdfRequestSetCompletionRoutine)(
4742
5217
_In_
4743
5218
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4752
5227
_IRQL_requires_max_(DISPATCH_LEVEL)
4753
5228
WDFAPI
4754
5229
VOID
5230
+
STDCALL
4755
5231
WDFEXPORT(WdfRequestGetCompletionParams)(
4756
5232
_In_
4757
5233
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4765
5241
_IRQL_requires_max_(DISPATCH_LEVEL)
4766
5242
WDFAPI
4767
5243
NTSTATUS
5244
+
STDCALL
4768
5245
WDFEXPORT(WdfRequestAllocateTimer)(
4769
5246
_In_
4770
5247
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4775
5252
_IRQL_requires_max_(DISPATCH_LEVEL)
4776
5253
WDFAPI
4777
5254
VOID
5255
+
STDCALL
4778
5256
WDFEXPORT(WdfRequestComplete)(
4779
5257
_In_
4780
5258
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4787
5265
_IRQL_requires_max_(DISPATCH_LEVEL)
4788
5266
WDFAPI
4789
5267
VOID
5268
+
STDCALL
4790
5269
WDFEXPORT(WdfRequestCompleteWithPriorityBoost)(
4791
5270
_In_
4792
5271
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4801
5280
_IRQL_requires_max_(DISPATCH_LEVEL)
4802
5281
WDFAPI
4803
5282
VOID
5283
+
STDCALL
4804
5284
WDFEXPORT(WdfRequestCompleteWithInformation)(
4805
5285
_In_
4806
5286
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4815
5295
_IRQL_requires_max_(DISPATCH_LEVEL)
4816
5296
WDFAPI
4817
5297
VOID
5298
+
STDCALL
4818
5299
WDFEXPORT(WdfRequestGetParameters)(
4819
5300
_In_
4820
5301
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4828
5309
_IRQL_requires_max_(DISPATCH_LEVEL)
4829
5310
WDFAPI
4830
5311
NTSTATUS
5312
+
STDCALL
4831
5313
WDFEXPORT(WdfRequestRetrieveInputMemory)(
4832
5314
_In_
4833
5315
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4841
5323
_IRQL_requires_max_(DISPATCH_LEVEL)
4842
5324
WDFAPI
4843
5325
NTSTATUS
5326
+
STDCALL
4844
5327
WDFEXPORT(WdfRequestRetrieveOutputMemory)(
4845
5328
_In_
4846
5329
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4854
5337
_IRQL_requires_max_(DISPATCH_LEVEL)
4855
5338
WDFAPI
4856
5339
NTSTATUS
5340
+
STDCALL
4857
5341
WDFEXPORT(WdfRequestRetrieveInputBuffer)(
4858
5342
_In_
4859
5343
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4871
5355
_IRQL_requires_max_(DISPATCH_LEVEL)
4872
5356
WDFAPI
4873
5357
NTSTATUS
5358
+
STDCALL
4874
5359
WDFEXPORT(WdfRequestRetrieveOutputBuffer)(
4875
5360
_In_
4876
5361
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4888
5373
_IRQL_requires_max_(DISPATCH_LEVEL)
4889
5374
WDFAPI
4890
5375
NTSTATUS
5376
+
STDCALL
4891
5377
WDFEXPORT(WdfRequestRetrieveInputWdmMdl)(
4892
5378
_In_
4893
5379
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4901
5387
_IRQL_requires_max_(DISPATCH_LEVEL)
4902
5388
WDFAPI
4903
5389
NTSTATUS
5390
+
STDCALL
4904
5391
WDFEXPORT(WdfRequestRetrieveOutputWdmMdl)(
4905
5392
_In_
4906
5393
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4914
5401
_IRQL_requires_max_(PASSIVE_LEVEL)
4915
5402
WDFAPI
4916
5403
NTSTATUS
5404
+
STDCALL
4917
5405
WDFEXPORT(WdfRequestRetrieveUnsafeUserInputBuffer)(
4918
5406
_In_
4919
5407
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4931
5419
_IRQL_requires_max_(PASSIVE_LEVEL)
4932
5420
WDFAPI
4933
5421
NTSTATUS
5422
+
STDCALL
4934
5423
WDFEXPORT(WdfRequestRetrieveUnsafeUserOutputBuffer)(
4935
5424
_In_
4936
5425
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4947
5436
_IRQL_requires_max_(DISPATCH_LEVEL)
4948
5437
WDFAPI
4949
5438
VOID
5439
+
STDCALL
4950
5440
WDFEXPORT(WdfRequestSetInformation)(
4951
5441
_In_
4952
5442
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4959
5449
_IRQL_requires_max_(DISPATCH_LEVEL)
4960
5450
WDFAPI
4961
5451
ULONG_PTR
5452
+
STDCALL
4962
5453
WDFEXPORT(WdfRequestGetInformation)(
4963
5454
_In_
4964
5455
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4969
5460
_IRQL_requires_max_(DISPATCH_LEVEL)
4970
5461
WDFAPI
4971
5462
WDFFILEOBJECT
5463
+
STDCALL
4972
5464
WDFEXPORT(WdfRequestGetFileObject)(
4973
5465
_In_
4974
5466
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4980
5472
_IRQL_requires_max_(PASSIVE_LEVEL)
4981
5473
WDFAPI
4982
5474
NTSTATUS
5475
+
STDCALL
4983
5476
WDFEXPORT(WdfRequestProbeAndLockUserBufferForRead)(
4984
5477
_In_
4985
5478
PWDF_DRIVER_GLOBALS DriverGlobals,
···
4997
5490
_IRQL_requires_max_(PASSIVE_LEVEL)
4998
5491
WDFAPI
4999
5492
NTSTATUS
5493
+
STDCALL
5000
5494
WDFEXPORT(WdfRequestProbeAndLockUserBufferForWrite)(
5001
5495
_In_
5002
5496
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5013
5507
_IRQL_requires_max_(DISPATCH_LEVEL)
5014
5508
WDFAPI
5015
5509
KPROCESSOR_MODE
5510
+
STDCALL
5016
5511
WDFEXPORT(WdfRequestGetRequestorMode)(
5017
5512
_In_
5018
5513
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5024
5519
_IRQL_requires_max_(DISPATCH_LEVEL)
5025
5520
WDFAPI
5026
5521
NTSTATUS
5522
+
STDCALL
5027
5523
WDFEXPORT(WdfRequestForwardToIoQueue)(
5028
5524
_In_
5029
5525
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5036
5532
_IRQL_requires_max_(DISPATCH_LEVEL)
5037
5533
WDFAPI
5038
5534
WDFQUEUE
5535
+
STDCALL
5039
5536
WDFEXPORT(WdfRequestGetIoQueue)(
5040
5537
_In_
5041
5538
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5047
5544
_IRQL_requires_max_(DISPATCH_LEVEL)
5048
5545
WDFAPI
5049
5546
NTSTATUS
5547
+
STDCALL
5050
5548
WDFEXPORT(WdfRequestRequeue)(
5051
5549
_In_
5052
5550
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5057
5555
_IRQL_requires_max_(DISPATCH_LEVEL)
5058
5556
WDFAPI
5059
5557
VOID
5558
+
STDCALL
5060
5559
WDFEXPORT(WdfRequestStopAcknowledge)(
5061
5560
_In_
5062
5561
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5069
5568
_IRQL_requires_max_(DISPATCH_LEVEL)
5070
5569
WDFAPI
5071
5570
PIRP
5571
+
STDCALL
5072
5572
WDFEXPORT(WdfRequestWdmGetIrp)(
5073
5573
_In_
5074
5574
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5079
5579
_IRQL_requires_max_(DISPATCH_LEVEL)
5080
5580
WDFAPI
5081
5581
BOOLEAN
5582
+
STDCALL
5082
5583
WDFEXPORT(WdfRequestIsReserved)(
5083
5584
_In_
5084
5585
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5090
5591
_IRQL_requires_max_(DISPATCH_LEVEL)
5091
5592
WDFAPI
5092
5593
NTSTATUS
5594
+
STDCALL
5093
5595
WDFEXPORT(WdfRequestForwardToParentDeviceIoQueue)(
5094
5596
_In_
5095
5597
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5104
5606
_IRQL_requires_max_(DISPATCH_LEVEL)
5105
5607
WDFAPI
5106
5608
VOID
5609
+
STDCALL
5107
5610
WDFEXPORT(WdfIoResourceRequirementsListSetSlotNumber)(
5108
5611
_In_
5109
5612
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5116
5619
_IRQL_requires_max_(DISPATCH_LEVEL)
5117
5620
WDFAPI
5118
5621
VOID
5622
+
STDCALL
5119
5623
WDFEXPORT(WdfIoResourceRequirementsListSetInterfaceType)(
5120
5624
_In_
5121
5625
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5130
5634
_IRQL_requires_max_(DISPATCH_LEVEL)
5131
5635
WDFAPI
5132
5636
NTSTATUS
5637
+
STDCALL
5133
5638
WDFEXPORT(WdfIoResourceRequirementsListAppendIoResList)(
5134
5639
_In_
5135
5640
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5143
5648
_IRQL_requires_max_(DISPATCH_LEVEL)
5144
5649
WDFAPI
5145
5650
NTSTATUS
5651
+
STDCALL
5146
5652
WDFEXPORT(WdfIoResourceRequirementsListInsertIoResList)(
5147
5653
_In_
5148
5654
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5157
5663
_IRQL_requires_max_(DISPATCH_LEVEL)
5158
5664
WDFAPI
5159
5665
ULONG
5666
+
STDCALL
5160
5667
WDFEXPORT(WdfIoResourceRequirementsListGetCount)(
5161
5668
_In_
5162
5669
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5167
5674
_IRQL_requires_max_(DISPATCH_LEVEL)
5168
5675
WDFAPI
5169
5676
WDFIORESLIST
5677
+
STDCALL
5170
5678
WDFEXPORT(WdfIoResourceRequirementsListGetIoResList)(
5171
5679
_In_
5172
5680
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5179
5687
_IRQL_requires_max_(DISPATCH_LEVEL)
5180
5688
WDFAPI
5181
5689
VOID
5690
+
STDCALL
5182
5691
WDFEXPORT(WdfIoResourceRequirementsListRemove)(
5183
5692
_In_
5184
5693
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5191
5700
_IRQL_requires_max_(DISPATCH_LEVEL)
5192
5701
WDFAPI
5193
5702
VOID
5703
+
STDCALL
5194
5704
WDFEXPORT(WdfIoResourceRequirementsListRemoveByIoResList)(
5195
5705
_In_
5196
5706
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5204
5714
_IRQL_requires_max_(DISPATCH_LEVEL)
5205
5715
WDFAPI
5206
5716
NTSTATUS
5717
+
STDCALL
5207
5718
WDFEXPORT(WdfIoResourceListCreate)(
5208
5719
_In_
5209
5720
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5219
5730
_IRQL_requires_max_(DISPATCH_LEVEL)
5220
5731
WDFAPI
5221
5732
NTSTATUS
5733
+
STDCALL
5222
5734
WDFEXPORT(WdfIoResourceListAppendDescriptor)(
5223
5735
_In_
5224
5736
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5232
5744
_IRQL_requires_max_(DISPATCH_LEVEL)
5233
5745
WDFAPI
5234
5746
NTSTATUS
5747
+
STDCALL
5235
5748
WDFEXPORT(WdfIoResourceListInsertDescriptor)(
5236
5749
_In_
5237
5750
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5246
5759
_IRQL_requires_max_(DISPATCH_LEVEL)
5247
5760
WDFAPI
5248
5761
VOID
5762
+
STDCALL
5249
5763
WDFEXPORT(WdfIoResourceListUpdateDescriptor)(
5250
5764
_In_
5251
5765
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5260
5774
_IRQL_requires_max_(DISPATCH_LEVEL)
5261
5775
WDFAPI
5262
5776
ULONG
5777
+
STDCALL
5263
5778
WDFEXPORT(WdfIoResourceListGetCount)(
5264
5779
_In_
5265
5780
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5270
5785
_IRQL_requires_max_(DISPATCH_LEVEL)
5271
5786
WDFAPI
5272
5787
PIO_RESOURCE_DESCRIPTOR
5788
+
STDCALL
5273
5789
WDFEXPORT(WdfIoResourceListGetDescriptor)(
5274
5790
_In_
5275
5791
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5282
5798
_IRQL_requires_max_(DISPATCH_LEVEL)
5283
5799
WDFAPI
5284
5800
VOID
5801
+
STDCALL
5285
5802
WDFEXPORT(WdfIoResourceListRemove)(
5286
5803
_In_
5287
5804
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5294
5811
_IRQL_requires_max_(DISPATCH_LEVEL)
5295
5812
WDFAPI
5296
5813
VOID
5814
+
STDCALL
5297
5815
WDFEXPORT(WdfIoResourceListRemoveByDescriptor)(
5298
5816
_In_
5299
5817
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5307
5825
_IRQL_requires_max_(DISPATCH_LEVEL)
5308
5826
WDFAPI
5309
5827
NTSTATUS
5828
+
STDCALL
5310
5829
WDFEXPORT(WdfCmResourceListAppendDescriptor)(
5311
5830
_In_
5312
5831
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5320
5839
_IRQL_requires_max_(DISPATCH_LEVEL)
5321
5840
WDFAPI
5322
5841
NTSTATUS
5842
+
STDCALL
5323
5843
WDFEXPORT(WdfCmResourceListInsertDescriptor)(
5324
5844
_In_
5325
5845
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5334
5854
_IRQL_requires_max_(DISPATCH_LEVEL)
5335
5855
WDFAPI
5336
5856
ULONG
5857
+
STDCALL
5337
5858
WDFEXPORT(WdfCmResourceListGetCount)(
5338
5859
_In_
5339
5860
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5344
5865
_IRQL_requires_max_(DISPATCH_LEVEL)
5345
5866
WDFAPI
5346
5867
PCM_PARTIAL_RESOURCE_DESCRIPTOR
5868
+
STDCALL
5347
5869
WDFEXPORT(WdfCmResourceListGetDescriptor)(
5348
5870
_In_
5349
5871
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5356
5878
_IRQL_requires_max_(DISPATCH_LEVEL)
5357
5879
WDFAPI
5358
5880
VOID
5881
+
STDCALL
5359
5882
WDFEXPORT(WdfCmResourceListRemove)(
5360
5883
_In_
5361
5884
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5368
5891
_IRQL_requires_max_(DISPATCH_LEVEL)
5369
5892
WDFAPI
5370
5893
VOID
5894
+
STDCALL
5371
5895
WDFEXPORT(WdfCmResourceListRemoveByDescriptor)(
5372
5896
_In_
5373
5897
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5381
5905
_IRQL_requires_max_(PASSIVE_LEVEL)
5382
5906
WDFAPI
5383
5907
NTSTATUS
5908
+
STDCALL
5384
5909
WDFEXPORT(WdfStringCreate)(
5385
5910
_In_
5386
5911
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5395
5920
_IRQL_requires_max_(PASSIVE_LEVEL)
5396
5921
WDFAPI
5397
5922
VOID
5923
+
STDCALL
5398
5924
WDFEXPORT(WdfStringGetUnicodeString)(
5399
5925
_In_
5400
5926
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5407
5933
_IRQL_requires_max_(DISPATCH_LEVEL)
5408
5934
WDFAPI
5409
5935
VOID
5936
+
STDCALL
5410
5937
WDFEXPORT(WdfObjectAcquireLock)(
5411
5938
_In_
5412
5939
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5419
5946
_IRQL_requires_max_(DISPATCH_LEVEL)
5420
5947
WDFAPI
5421
5948
VOID
5949
+
STDCALL
5422
5950
WDFEXPORT(WdfObjectReleaseLock)(
5423
5951
_In_
5424
5952
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5432
5960
_IRQL_requires_max_(DISPATCH_LEVEL)
5433
5961
WDFAPI
5434
5962
NTSTATUS
5963
+
STDCALL
5435
5964
WDFEXPORT(WdfWaitLockCreate)(
5436
5965
_In_
5437
5966
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5449
5978
_When_(Timeout != NULL, _Must_inspect_result_)
5450
5979
WDFAPI
5451
5980
NTSTATUS
5981
+
STDCALL
5452
5982
WDFEXPORT(WdfWaitLockAcquire)(
5453
5983
_In_
5454
5984
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5462
5992
_IRQL_requires_max_(DISPATCH_LEVEL)
5463
5993
WDFAPI
5464
5994
VOID
5995
+
STDCALL
5465
5996
WDFEXPORT(WdfWaitLockRelease)(
5466
5997
_In_
5467
5998
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5475
6006
_IRQL_requires_max_(DISPATCH_LEVEL)
5476
6007
WDFAPI
5477
6008
NTSTATUS
6009
+
STDCALL
5478
6010
WDFEXPORT(WdfSpinLockCreate)(
5479
6011
_In_
5480
6012
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5488
6020
_IRQL_raises_(DISPATCH_LEVEL)
5489
6021
WDFAPI
5490
6022
VOID
6023
+
STDCALL
5491
6024
WDFEXPORT(WdfSpinLockAcquire)(
5492
6025
_In_
5493
6026
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5502
6035
_IRQL_requires_min_(DISPATCH_LEVEL)
5503
6036
WDFAPI
5504
6037
VOID
6038
+
STDCALL
5505
6039
WDFEXPORT(WdfSpinLockRelease)(
5506
6040
_In_
5507
6041
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5516
6050
_IRQL_requires_max_(DISPATCH_LEVEL)
5517
6051
WDFAPI
5518
6052
NTSTATUS
6053
+
STDCALL
5519
6054
WDFEXPORT(WdfTimerCreate)(
5520
6055
_In_
5521
6056
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5530
6065
_IRQL_requires_max_(DISPATCH_LEVEL)
5531
6066
WDFAPI
5532
6067
BOOLEAN
6068
+
STDCALL
5533
6069
WDFEXPORT(WdfTimerStart)(
5534
6070
_In_
5535
6071
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5543
6079
_When_(Wait == __false, _IRQL_requires_max_(DISPATCH_LEVEL))
5544
6080
WDFAPI
5545
6081
BOOLEAN
6082
+
STDCALL
5546
6083
WDFEXPORT(WdfTimerStop)(
5547
6084
_In_
5548
6085
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5555
6092
_IRQL_requires_max_(DISPATCH_LEVEL)
5556
6093
WDFAPI
5557
6094
WDFOBJECT
6095
+
STDCALL
5558
6096
WDFEXPORT(WdfTimerGetParentObject)(
5559
6097
_In_
5560
6098
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5566
6104
_IRQL_requires_max_(PASSIVE_LEVEL)
5567
6105
WDFAPI
5568
6106
NTSTATUS
6107
+
STDCALL
5569
6108
WDFEXPORT(WdfUsbTargetDeviceCreate)(
5570
6109
_In_
5571
6110
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5581
6120
_IRQL_requires_max_(PASSIVE_LEVEL)
5582
6121
WDFAPI
5583
6122
NTSTATUS
6123
+
STDCALL
5584
6124
WDFEXPORT(WdfUsbTargetDeviceCreateWithParameters)(
5585
6125
_In_
5586
6126
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5598
6138
_IRQL_requires_max_(DISPATCH_LEVEL)
5599
6139
WDFAPI
5600
6140
NTSTATUS
6141
+
STDCALL
5601
6142
WDFEXPORT(WdfUsbTargetDeviceRetrieveInformation)(
5602
6143
_In_
5603
6144
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5610
6151
_IRQL_requires_max_(PASSIVE_LEVEL)
5611
6152
WDFAPI
5612
6153
VOID
6154
+
STDCALL
5613
6155
WDFEXPORT(WdfUsbTargetDeviceGetDeviceDescriptor)(
5614
6156
_In_
5615
6157
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5623
6165
_IRQL_requires_max_(PASSIVE_LEVEL)
5624
6166
WDFAPI
5625
6167
NTSTATUS
6168
+
STDCALL
5626
6169
WDFEXPORT(WdfUsbTargetDeviceRetrieveConfigDescriptor)(
5627
6170
_In_
5628
6171
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5638
6181
_IRQL_requires_max_(PASSIVE_LEVEL)
5639
6182
WDFAPI
5640
6183
NTSTATUS
6184
+
STDCALL
5641
6185
WDFEXPORT(WdfUsbTargetDeviceQueryString)(
5642
6186
_In_
5643
6187
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5661
6205
_IRQL_requires_max_(PASSIVE_LEVEL)
5662
6206
WDFAPI
5663
6207
NTSTATUS
6208
+
STDCALL
5664
6209
WDFEXPORT(WdfUsbTargetDeviceAllocAndQueryString)(
5665
6210
_In_
5666
6211
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5682
6227
_IRQL_requires_max_(DISPATCH_LEVEL)
5683
6228
WDFAPI
5684
6229
NTSTATUS
6230
+
STDCALL
5685
6231
WDFEXPORT(WdfUsbTargetDeviceFormatRequestForString)(
5686
6232
_In_
5687
6233
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5702
6248
_IRQL_requires_max_(DISPATCH_LEVEL)
5703
6249
WDFAPI
5704
6250
UCHAR
6251
+
STDCALL
5705
6252
WDFEXPORT(WdfUsbTargetDeviceGetNumInterfaces)(
5706
6253
_In_
5707
6254
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5713
6260
_IRQL_requires_max_(PASSIVE_LEVEL)
5714
6261
WDFAPI
5715
6262
NTSTATUS
6263
+
STDCALL
5716
6264
WDFEXPORT(WdfUsbTargetDeviceSelectConfig)(
5717
6265
_In_
5718
6266
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5727
6275
_IRQL_requires_max_(DISPATCH_LEVEL)
5728
6276
WDFAPI
5729
6277
USBD_CONFIGURATION_HANDLE
6278
+
STDCALL
5730
6279
WDFEXPORT(WdfUsbTargetDeviceWdmGetConfigurationHandle)(
5731
6280
_In_
5732
6281
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5738
6287
_IRQL_requires_max_(DISPATCH_LEVEL)
5739
6288
WDFAPI
5740
6289
NTSTATUS
6290
+
STDCALL
5741
6291
WDFEXPORT(WdfUsbTargetDeviceRetrieveCurrentFrameNumber)(
5742
6292
_In_
5743
6293
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5751
6301
_IRQL_requires_max_(PASSIVE_LEVEL)
5752
6302
WDFAPI
5753
6303
NTSTATUS
6304
+
STDCALL
5754
6305
WDFEXPORT(WdfUsbTargetDeviceSendControlTransferSynchronously)(
5755
6306
_In_
5756
6307
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5772
6323
_IRQL_requires_max_(DISPATCH_LEVEL)
5773
6324
WDFAPI
5774
6325
NTSTATUS
6326
+
STDCALL
5775
6327
WDFEXPORT(WdfUsbTargetDeviceFormatRequestForControlTransfer)(
5776
6328
_In_
5777
6329
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5791
6343
_IRQL_requires_max_(PASSIVE_LEVEL)
5792
6344
WDFAPI
5793
6345
NTSTATUS
6346
+
STDCALL
5794
6347
WDFEXPORT(WdfUsbTargetDeviceIsConnectedSynchronous)(
5795
6348
_In_
5796
6349
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5802
6355
_IRQL_requires_max_(PASSIVE_LEVEL)
5803
6356
WDFAPI
5804
6357
NTSTATUS
6358
+
STDCALL
5805
6359
WDFEXPORT(WdfUsbTargetDeviceResetPortSynchronously)(
5806
6360
_In_
5807
6361
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5813
6367
_IRQL_requires_max_(PASSIVE_LEVEL)
5814
6368
WDFAPI
5815
6369
NTSTATUS
6370
+
STDCALL
5816
6371
WDFEXPORT(WdfUsbTargetDeviceCyclePortSynchronously)(
5817
6372
_In_
5818
6373
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5824
6379
_IRQL_requires_max_(DISPATCH_LEVEL)
5825
6380
WDFAPI
5826
6381
NTSTATUS
6382
+
STDCALL
5827
6383
WDFEXPORT(WdfUsbTargetDeviceFormatRequestForCyclePort)(
5828
6384
_In_
5829
6385
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5837
6393
_IRQL_requires_max_(PASSIVE_LEVEL)
5838
6394
WDFAPI
5839
6395
NTSTATUS
6396
+
STDCALL
5840
6397
WDFEXPORT(WdfUsbTargetDeviceSendUrbSynchronously)(
5841
6398
_In_
5842
6399
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5854
6411
_IRQL_requires_max_(DISPATCH_LEVEL)
5855
6412
WDFAPI
5856
6413
NTSTATUS
6414
+
STDCALL
5857
6415
WDFEXPORT(WdfUsbTargetDeviceFormatRequestForUrb)(
5858
6416
_In_
5859
6417
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5871
6429
_IRQL_requires_max_(PASSIVE_LEVEL)
5872
6430
WDFAPI
5873
6431
NTSTATUS
6432
+
STDCALL
5874
6433
WDFEXPORT(WdfUsbTargetDeviceQueryUsbCapability)(
5875
6434
_In_
5876
6435
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5893
6452
_IRQL_requires_max_(DISPATCH_LEVEL)
5894
6453
WDFAPI
5895
6454
NTSTATUS
6455
+
STDCALL
5896
6456
WDFEXPORT(WdfUsbTargetDeviceCreateUrb)(
5897
6457
_In_
5898
6458
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5910
6470
_IRQL_requires_max_(DISPATCH_LEVEL)
5911
6471
WDFAPI
5912
6472
NTSTATUS
6473
+
STDCALL
5913
6474
WDFEXPORT(WdfUsbTargetDeviceCreateIsochUrb)(
5914
6475
_In_
5915
6476
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5928
6489
_IRQL_requires_max_(DISPATCH_LEVEL)
5929
6490
WDFAPI
5930
6491
VOID
6492
+
STDCALL
5931
6493
WDFEXPORT(WdfUsbTargetPipeGetInformation)(
5932
6494
_In_
5933
6495
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5940
6502
_IRQL_requires_max_(DISPATCH_LEVEL)
5941
6503
WDFAPI
5942
6504
BOOLEAN
6505
+
STDCALL
5943
6506
WDFEXPORT(WdfUsbTargetPipeIsInEndpoint)(
5944
6507
_In_
5945
6508
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5950
6513
_IRQL_requires_max_(DISPATCH_LEVEL)
5951
6514
WDFAPI
5952
6515
BOOLEAN
6516
+
STDCALL
5953
6517
WDFEXPORT(WdfUsbTargetPipeIsOutEndpoint)(
5954
6518
_In_
5955
6519
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5960
6524
_IRQL_requires_max_(DISPATCH_LEVEL)
5961
6525
WDFAPI
5962
6526
WDF_USB_PIPE_TYPE
6527
+
STDCALL
5963
6528
WDFEXPORT(WdfUsbTargetPipeGetType)(
5964
6529
_In_
5965
6530
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5970
6535
_IRQL_requires_max_(DISPATCH_LEVEL)
5971
6536
WDFAPI
5972
6537
VOID
6538
+
STDCALL
5973
6539
WDFEXPORT(WdfUsbTargetPipeSetNoMaximumPacketSizeCheck)(
5974
6540
_In_
5975
6541
PWDF_DRIVER_GLOBALS DriverGlobals,
···
5981
6547
_IRQL_requires_max_(PASSIVE_LEVEL)
5982
6548
WDFAPI
5983
6549
NTSTATUS
6550
+
STDCALL
5984
6551
WDFEXPORT(WdfUsbTargetPipeWriteSynchronously)(
5985
6552
_In_
5986
6553
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6000
6567
_IRQL_requires_max_(DISPATCH_LEVEL)
6001
6568
WDFAPI
6002
6569
NTSTATUS
6570
+
STDCALL
6003
6571
WDFEXPORT(WdfUsbTargetPipeFormatRequestForWrite)(
6004
6572
_In_
6005
6573
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6017
6585
_IRQL_requires_max_(PASSIVE_LEVEL)
6018
6586
WDFAPI
6019
6587
NTSTATUS
6588
+
STDCALL
6020
6589
WDFEXPORT(WdfUsbTargetPipeReadSynchronously)(
6021
6590
_In_
6022
6591
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6036
6605
_IRQL_requires_max_(DISPATCH_LEVEL)
6037
6606
WDFAPI
6038
6607
NTSTATUS
6608
+
STDCALL
6039
6609
WDFEXPORT(WdfUsbTargetPipeFormatRequestForRead)(
6040
6610
_In_
6041
6611
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6053
6623
_IRQL_requires_max_(DISPATCH_LEVEL)
6054
6624
WDFAPI
6055
6625
NTSTATUS
6626
+
STDCALL
6056
6627
WDFEXPORT(WdfUsbTargetPipeConfigContinuousReader)(
6057
6628
_In_
6058
6629
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6066
6637
_IRQL_requires_max_(PASSIVE_LEVEL)
6067
6638
WDFAPI
6068
6639
NTSTATUS
6640
+
STDCALL
6069
6641
WDFEXPORT(WdfUsbTargetPipeAbortSynchronously)(
6070
6642
_In_
6071
6643
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6081
6653
_IRQL_requires_max_(DISPATCH_LEVEL)
6082
6654
WDFAPI
6083
6655
NTSTATUS
6656
+
STDCALL
6084
6657
WDFEXPORT(WdfUsbTargetPipeFormatRequestForAbort)(
6085
6658
_In_
6086
6659
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6094
6667
_IRQL_requires_max_(PASSIVE_LEVEL)
6095
6668
WDFAPI
6096
6669
NTSTATUS
6670
+
STDCALL
6097
6671
WDFEXPORT(WdfUsbTargetPipeResetSynchronously)(
6098
6672
_In_
6099
6673
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6109
6683
_IRQL_requires_max_(DISPATCH_LEVEL)
6110
6684
WDFAPI
6111
6685
NTSTATUS
6686
+
STDCALL
6112
6687
WDFEXPORT(WdfUsbTargetPipeFormatRequestForReset)(
6113
6688
_In_
6114
6689
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6122
6697
_IRQL_requires_max_(PASSIVE_LEVEL)
6123
6698
WDFAPI
6124
6699
NTSTATUS
6700
+
STDCALL
6125
6701
WDFEXPORT(WdfUsbTargetPipeSendUrbSynchronously)(
6126
6702
_In_
6127
6703
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6139
6715
_IRQL_requires_max_(DISPATCH_LEVEL)
6140
6716
WDFAPI
6141
6717
NTSTATUS
6718
+
STDCALL
6142
6719
WDFEXPORT(WdfUsbTargetPipeFormatRequestForUrb)(
6143
6720
_In_
6144
6721
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6155
6732
_IRQL_requires_max_(DISPATCH_LEVEL)
6156
6733
WDFAPI
6157
6734
BYTE
6735
+
STDCALL
6158
6736
WDFEXPORT(WdfUsbInterfaceGetInterfaceNumber)(
6159
6737
_In_
6160
6738
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6165
6743
_IRQL_requires_max_(DISPATCH_LEVEL)
6166
6744
WDFAPI
6167
6745
BYTE
6746
+
STDCALL
6168
6747
WDFEXPORT(WdfUsbInterfaceGetNumEndpoints)(
6169
6748
_In_
6170
6749
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6177
6756
_IRQL_requires_max_(DISPATCH_LEVEL)
6178
6757
WDFAPI
6179
6758
VOID
6759
+
STDCALL
6180
6760
WDFEXPORT(WdfUsbInterfaceGetDescriptor)(
6181
6761
_In_
6182
6762
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6191
6771
_IRQL_requires_max_(DISPATCH_LEVEL)
6192
6772
WDFAPI
6193
6773
BYTE
6774
+
STDCALL
6194
6775
WDFEXPORT(WdfUsbInterfaceGetNumSettings)(
6195
6776
_In_
6196
6777
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6202
6783
_IRQL_requires_max_(PASSIVE_LEVEL)
6203
6784
WDFAPI
6204
6785
NTSTATUS
6786
+
STDCALL
6205
6787
WDFEXPORT(WdfUsbInterfaceSelectSetting)(
6206
6788
_In_
6207
6789
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6216
6798
_IRQL_requires_max_(DISPATCH_LEVEL)
6217
6799
WDFAPI
6218
6800
VOID
6801
+
STDCALL
6219
6802
WDFEXPORT(WdfUsbInterfaceGetEndpointInformation)(
6220
6803
_In_
6221
6804
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6232
6815
_IRQL_requires_max_(DISPATCH_LEVEL)
6233
6816
WDFAPI
6234
6817
WDFUSBINTERFACE
6818
+
STDCALL
6235
6819
WDFEXPORT(WdfUsbTargetDeviceGetInterface)(
6236
6820
_In_
6237
6821
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6244
6828
_IRQL_requires_max_(DISPATCH_LEVEL)
6245
6829
WDFAPI
6246
6830
BYTE
6831
+
STDCALL
6247
6832
WDFEXPORT(WdfUsbInterfaceGetConfiguredSettingIndex)(
6248
6833
_In_
6249
6834
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6254
6839
_IRQL_requires_max_(DISPATCH_LEVEL)
6255
6840
WDFAPI
6256
6841
BYTE
6842
+
STDCALL
6257
6843
WDFEXPORT(WdfUsbInterfaceGetNumConfiguredPipes)(
6258
6844
_In_
6259
6845
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6264
6850
_IRQL_requires_max_(DISPATCH_LEVEL)
6265
6851
WDFAPI
6266
6852
WDFUSBPIPE
6853
+
STDCALL
6267
6854
WDFEXPORT(WdfUsbInterfaceGetConfiguredPipe)(
6268
6855
_In_
6269
6856
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6278
6865
_IRQL_requires_max_(DISPATCH_LEVEL)
6279
6866
WDFAPI
6280
6867
USBD_PIPE_HANDLE
6868
+
STDCALL
6281
6869
WDFEXPORT(WdfUsbTargetPipeWdmGetPipeHandle)(
6282
6870
_In_
6283
6871
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6287
6875
6288
6876
WDFAPI
6289
6877
VOID
6878
+
STDCALL
6290
6879
WDFEXPORT(WdfVerifierDbgBreakPoint)(
6291
6880
_In_
6292
6881
PWDF_DRIVER_GLOBALS DriverGlobals
···
6294
6883
6295
6884
WDFAPI
6296
6885
VOID
6886
+
STDCALL
6297
6887
WDFEXPORT(WdfVerifierKeBugCheck)(
6298
6888
_In_
6299
6889
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6311
6901
6312
6902
WDFAPI
6313
6903
PVOID
6904
+
STDCALL
6314
6905
WDFEXPORT(WdfGetTriageInfo)(
6315
6906
_In_
6316
6907
PWDF_DRIVER_GLOBALS DriverGlobals
···
6320
6911
_IRQL_requires_max_(DISPATCH_LEVEL)
6321
6912
WDFAPI
6322
6913
NTSTATUS
6914
+
STDCALL
6323
6915
WDFEXPORT(WdfWmiProviderCreate)(
6324
6916
_In_
6325
6917
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6336
6928
_IRQL_requires_max_(DISPATCH_LEVEL)
6337
6929
WDFAPI
6338
6930
WDFDEVICE
6931
+
STDCALL
6339
6932
WDFEXPORT(WdfWmiProviderGetDevice)(
6340
6933
_In_
6341
6934
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6346
6939
_IRQL_requires_max_(DISPATCH_LEVEL)
6347
6940
WDFAPI
6348
6941
BOOLEAN
6942
+
STDCALL
6349
6943
WDFEXPORT(WdfWmiProviderIsEnabled)(
6350
6944
_In_
6351
6945
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6358
6952
_IRQL_requires_max_(DISPATCH_LEVEL)
6359
6953
WDFAPI
6360
6954
ULONGLONG
6955
+
STDCALL
6361
6956
WDFEXPORT(WdfWmiProviderGetTracingHandle)(
6362
6957
_In_
6363
6958
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6369
6964
_IRQL_requires_max_(DISPATCH_LEVEL)
6370
6965
WDFAPI
6371
6966
NTSTATUS
6967
+
STDCALL
6372
6968
WDFEXPORT(WdfWmiInstanceCreate)(
6373
6969
_In_
6374
6970
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6386
6982
_IRQL_requires_max_(PASSIVE_LEVEL)
6387
6983
WDFAPI
6388
6984
NTSTATUS
6985
+
STDCALL
6389
6986
WDFEXPORT(WdfWmiInstanceRegister)(
6390
6987
_In_
6391
6988
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6396
6993
_IRQL_requires_max_(PASSIVE_LEVEL)
6397
6994
WDFAPI
6398
6995
VOID
6996
+
STDCALL
6399
6997
WDFEXPORT(WdfWmiInstanceDeregister)(
6400
6998
_In_
6401
6999
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6406
7004
_IRQL_requires_max_(DISPATCH_LEVEL)
6407
7005
WDFAPI
6408
7006
WDFDEVICE
7007
+
STDCALL
6409
7008
WDFEXPORT(WdfWmiInstanceGetDevice)(
6410
7009
_In_
6411
7010
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6416
7015
_IRQL_requires_max_(DISPATCH_LEVEL)
6417
7016
WDFAPI
6418
7017
WDFWMIPROVIDER
7018
+
STDCALL
6419
7019
WDFEXPORT(WdfWmiInstanceGetProvider)(
6420
7020
_In_
6421
7021
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6427
7027
_IRQL_requires_max_(APC_LEVEL)
6428
7028
WDFAPI
6429
7029
NTSTATUS
7030
+
STDCALL
6430
7031
WDFEXPORT(WdfWmiInstanceFireEvent)(
6431
7032
_In_
6432
7033
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6442
7043
_IRQL_requires_max_(DISPATCH_LEVEL)
6443
7044
WDFAPI
6444
7045
NTSTATUS
7046
+
STDCALL
6445
7047
WDFEXPORT(WdfWorkItemCreate)(
6446
7048
_In_
6447
7049
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6456
7058
_IRQL_requires_max_(DISPATCH_LEVEL)
6457
7059
WDFAPI
6458
7060
VOID
7061
+
STDCALL
6459
7062
WDFEXPORT(WdfWorkItemEnqueue)(
6460
7063
_In_
6461
7064
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6466
7069
_IRQL_requires_max_(DISPATCH_LEVEL)
6467
7070
WDFAPI
6468
7071
WDFOBJECT
7072
+
STDCALL
6469
7073
WDFEXPORT(WdfWorkItemGetParentObject)(
6470
7074
_In_
6471
7075
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6476
7080
_IRQL_requires_max_(PASSIVE_LEVEL)
6477
7081
WDFAPI
6478
7082
VOID
7083
+
STDCALL
6479
7084
WDFEXPORT(WdfWorkItemFlush)(
6480
7085
_In_
6481
7086
PWDF_DRIVER_GLOBALS DriverGlobals,
···
6511
7116
WDFEXPORT(WdfCollectionGetItem),
6512
7117
WDFEXPORT(WdfCollectionGetFirstItem),
6513
7118
WDFEXPORT(WdfCollectionGetLastItem),
6514
-
WDFEXPORT(WdfCommonBufferCreate),
6515
-
WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress),
6516
-
WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress),
6517
-
WDFEXPORT(WdfCommonBufferGetLength),
7119
+
// WDFEXPORT(WdfCommonBufferCreate),
7120
+
// WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress),
7121
+
// WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress),
7122
+
// WDFEXPORT(WdfCommonBufferGetLength),
7123
+
WdfApiNotImplemented,
7124
+
WdfApiNotImplemented,
7125
+
WdfApiNotImplemented,
7126
+
WdfApiNotImplemented,
7127
+
6518
7128
WDFEXPORT(WdfControlDeviceInitAllocate),
6519
7129
WDFEXPORT(WdfControlDeviceInitSetShutdownNotification),
6520
7130
WDFEXPORT(WdfControlFinishInitializing),
···
6584
7194
WDFEXPORT(WdfDeviceEnqueueRequest),
6585
7195
WDFEXPORT(WdfDeviceGetDefaultQueue),
6586
7196
WDFEXPORT(WdfDeviceConfigureRequestDispatching),
6587
-
WDFEXPORT(WdfDmaEnablerCreate),
6588
-
WDFEXPORT(WdfDmaEnablerGetMaximumLength),
6589
-
WDFEXPORT(WdfDmaEnablerGetMaximumScatterGatherElements),
6590
-
WDFEXPORT(WdfDmaEnablerSetMaximumScatterGatherElements),
6591
-
WDFEXPORT(WdfDmaTransactionCreate),
6592
-
WDFEXPORT(WdfDmaTransactionInitialize),
6593
-
WDFEXPORT(WdfDmaTransactionInitializeUsingRequest),
6594
-
WDFEXPORT(WdfDmaTransactionExecute),
6595
-
WDFEXPORT(WdfDmaTransactionRelease),
6596
-
WDFEXPORT(WdfDmaTransactionDmaCompleted),
6597
-
WDFEXPORT(WdfDmaTransactionDmaCompletedWithLength),
6598
-
WDFEXPORT(WdfDmaTransactionDmaCompletedFinal),
6599
-
WDFEXPORT(WdfDmaTransactionGetBytesTransferred),
6600
-
WDFEXPORT(WdfDmaTransactionSetMaximumLength),
6601
-
WDFEXPORT(WdfDmaTransactionGetRequest),
6602
-
WDFEXPORT(WdfDmaTransactionGetCurrentDmaTransferLength),
6603
-
WDFEXPORT(WdfDmaTransactionGetDevice),
7197
+
// WDFEXPORT(WdfDmaEnablerCreate),
7198
+
// WDFEXPORT(WdfDmaEnablerGetMaximumLength),
7199
+
// WDFEXPORT(WdfDmaEnablerGetMaximumScatterGatherElements),
7200
+
// WDFEXPORT(WdfDmaEnablerSetMaximumScatterGatherElements),
7201
+
// WDFEXPORT(WdfDmaTransactionCreate),
7202
+
// WDFEXPORT(WdfDmaTransactionInitialize),
7203
+
// WDFEXPORT(WdfDmaTransactionInitializeUsingRequest),
7204
+
// WDFEXPORT(WdfDmaTransactionExecute),
7205
+
// WDFEXPORT(WdfDmaTransactionRelease),
7206
+
// WDFEXPORT(WdfDmaTransactionDmaCompleted),
7207
+
// WDFEXPORT(WdfDmaTransactionDmaCompletedWithLength),
7208
+
// WDFEXPORT(WdfDmaTransactionDmaCompletedFinal),
7209
+
// WDFEXPORT(WdfDmaTransactionGetBytesTransferred),
7210
+
// WDFEXPORT(WdfDmaTransactionSetMaximumLength),
7211
+
// WDFEXPORT(WdfDmaTransactionGetRequest),
7212
+
// WDFEXPORT(WdfDmaTransactionGetCurrentDmaTransferLength),
7213
+
// WDFEXPORT(WdfDmaTransactionGetDevice),
7214
+
WdfApiNotImplemented,
7215
+
WdfApiNotImplemented,
7216
+
WdfApiNotImplemented,
7217
+
WdfApiNotImplemented,
7218
+
WdfApiNotImplemented,
7219
+
WdfApiNotImplemented,
7220
+
WdfApiNotImplemented,
7221
+
WdfApiNotImplemented,
7222
+
WdfApiNotImplemented,
7223
+
WdfApiNotImplemented,
7224
+
WdfApiNotImplemented,
7225
+
WdfApiNotImplemented,
7226
+
WdfApiNotImplemented,
7227
+
WdfApiNotImplemented,
7228
+
WdfApiNotImplemented,
7229
+
WdfApiNotImplemented,
7230
+
WdfApiNotImplemented,
7231
+
6604
7232
WDFEXPORT(WdfDpcCreate),
6605
7233
WDFEXPORT(WdfDpcEnqueue),
6606
7234
WDFEXPORT(WdfDpcCancel),
···
6631
7259
WDFEXPORT(WdfFileObjectGetFlags),
6632
7260
WDFEXPORT(WdfFileObjectGetDevice),
6633
7261
WDFEXPORT(WdfFileObjectWdmGetFileObject),
6634
-
WDFEXPORT(WdfInterruptCreate),
6635
-
WDFEXPORT(WdfInterruptQueueDpcForIsr),
6636
-
WDFEXPORT(WdfInterruptSynchronize),
6637
-
WDFEXPORT(WdfInterruptAcquireLock),
6638
-
WDFEXPORT(WdfInterruptReleaseLock),
6639
-
WDFEXPORT(WdfInterruptEnable),
6640
-
WDFEXPORT(WdfInterruptDisable),
6641
-
WDFEXPORT(WdfInterruptWdmGetInterrupt),
6642
-
WDFEXPORT(WdfInterruptGetInfo),
6643
-
WDFEXPORT(WdfInterruptSetPolicy),
6644
-
WDFEXPORT(WdfInterruptGetDevice),
7262
+
// WDFEXPORT(WdfInterruptCreate),
7263
+
// WDFEXPORT(WdfInterruptQueueDpcForIsr),
7264
+
// WDFEXPORT(WdfInterruptSynchronize),
7265
+
// WDFEXPORT(WdfInterruptAcquireLock),
7266
+
// WDFEXPORT(WdfInterruptReleaseLock),
7267
+
// WDFEXPORT(WdfInterruptEnable),
7268
+
// WDFEXPORT(WdfInterruptDisable),
7269
+
// WDFEXPORT(WdfInterruptWdmGetInterrupt),
7270
+
// WDFEXPORT(WdfInterruptGetInfo),
7271
+
// WDFEXPORT(WdfInterruptSetPolicy),
7272
+
// WDFEXPORT(WdfInterruptGetDevice),
7273
+
WdfApiNotImplemented,
7274
+
WdfApiNotImplemented,
7275
+
WdfApiNotImplemented,
7276
+
WdfApiNotImplemented,
7277
+
WdfApiNotImplemented,
7278
+
WdfApiNotImplemented,
7279
+
WdfApiNotImplemented,
7280
+
WdfApiNotImplemented,
7281
+
WdfApiNotImplemented,
7282
+
WdfApiNotImplemented,
7283
+
WdfApiNotImplemented,
7284
+
6645
7285
WDFEXPORT(WdfIoQueueCreate),
6646
7286
WDFEXPORT(WdfIoQueueGetState),
6647
7287
WDFEXPORT(WdfIoQueueStart),
···
6776
7416
WDFEXPORT(WdfRequestRequeue),
6777
7417
WDFEXPORT(WdfRequestStopAcknowledge),
6778
7418
WDFEXPORT(WdfRequestWdmGetIrp),
6779
-
WDFEXPORT(WdfIoResourceRequirementsListSetSlotNumber),
6780
-
WDFEXPORT(WdfIoResourceRequirementsListSetInterfaceType),
6781
-
WDFEXPORT(WdfIoResourceRequirementsListAppendIoResList),
6782
-
WDFEXPORT(WdfIoResourceRequirementsListInsertIoResList),
6783
-
WDFEXPORT(WdfIoResourceRequirementsListGetCount),
6784
-
WDFEXPORT(WdfIoResourceRequirementsListGetIoResList),
6785
-
WDFEXPORT(WdfIoResourceRequirementsListRemove),
6786
-
WDFEXPORT(WdfIoResourceRequirementsListRemoveByIoResList),
6787
-
WDFEXPORT(WdfIoResourceListCreate),
6788
-
WDFEXPORT(WdfIoResourceListAppendDescriptor),
6789
-
WDFEXPORT(WdfIoResourceListInsertDescriptor),
6790
-
WDFEXPORT(WdfIoResourceListUpdateDescriptor),
6791
-
WDFEXPORT(WdfIoResourceListGetCount),
6792
-
WDFEXPORT(WdfIoResourceListGetDescriptor),
6793
-
WDFEXPORT(WdfIoResourceListRemove),
6794
-
WDFEXPORT(WdfIoResourceListRemoveByDescriptor),
6795
-
WDFEXPORT(WdfCmResourceListAppendDescriptor),
6796
-
WDFEXPORT(WdfCmResourceListInsertDescriptor),
6797
-
WDFEXPORT(WdfCmResourceListGetCount),
6798
-
WDFEXPORT(WdfCmResourceListGetDescriptor),
6799
-
WDFEXPORT(WdfCmResourceListRemove),
6800
-
WDFEXPORT(WdfCmResourceListRemoveByDescriptor),
7419
+
// WDFEXPORT(WdfIoResourceRequirementsListSetSlotNumber),
7420
+
// WDFEXPORT(WdfIoResourceRequirementsListSetInterfaceType),
7421
+
// WDFEXPORT(WdfIoResourceRequirementsListAppendIoResList),
7422
+
// WDFEXPORT(WdfIoResourceRequirementsListInsertIoResList),
7423
+
// WDFEXPORT(WdfIoResourceRequirementsListGetCount),
7424
+
// WDFEXPORT(WdfIoResourceRequirementsListGetIoResList),
7425
+
// WDFEXPORT(WdfIoResourceRequirementsListRemove),
7426
+
// WDFEXPORT(WdfIoResourceRequirementsListRemoveByIoResList),
7427
+
// WDFEXPORT(WdfIoResourceListCreate),
7428
+
// WDFEXPORT(WdfIoResourceListAppendDescriptor),
7429
+
// WDFEXPORT(WdfIoResourceListInsertDescriptor),
7430
+
// WDFEXPORT(WdfIoResourceListUpdateDescriptor),
7431
+
// WDFEXPORT(WdfIoResourceListGetCount),
7432
+
// WDFEXPORT(WdfIoResourceListGetDescriptor),
7433
+
// WDFEXPORT(WdfIoResourceListRemove),
7434
+
// WDFEXPORT(WdfIoResourceListRemoveByDescriptor),
7435
+
// WDFEXPORT(WdfCmResourceListAppendDescriptor),
7436
+
// WDFEXPORT(WdfCmResourceListInsertDescriptor),
7437
+
// WDFEXPORT(WdfCmResourceListGetCount),
7438
+
// WDFEXPORT(WdfCmResourceListGetDescriptor),
7439
+
// WDFEXPORT(WdfCmResourceListRemove),
7440
+
// WDFEXPORT(WdfCmResourceListRemoveByDescriptor),
7441
+
WdfApiNotImplemented,
7442
+
WdfApiNotImplemented,
7443
+
WdfApiNotImplemented,
7444
+
WdfApiNotImplemented,
7445
+
WdfApiNotImplemented,
7446
+
WdfApiNotImplemented,
7447
+
WdfApiNotImplemented,
7448
+
WdfApiNotImplemented,
7449
+
WdfApiNotImplemented,
7450
+
WdfApiNotImplemented,
7451
+
WdfApiNotImplemented,
7452
+
WdfApiNotImplemented,
7453
+
WdfApiNotImplemented,
7454
+
WdfApiNotImplemented,
7455
+
WdfApiNotImplemented,
7456
+
WdfApiNotImplemented,
7457
+
WdfApiNotImplemented,
7458
+
WdfApiNotImplemented,
7459
+
WdfApiNotImplemented,
7460
+
WdfApiNotImplemented,
7461
+
WdfApiNotImplemented,
7462
+
WdfApiNotImplemented,
7463
+
6801
7464
WDFEXPORT(WdfStringCreate),
6802
7465
WDFEXPORT(WdfStringGetUnicodeString),
6803
7466
WDFEXPORT(WdfObjectAcquireLock),
···
6812
7475
WDFEXPORT(WdfTimerStart),
6813
7476
WDFEXPORT(WdfTimerStop),
6814
7477
WDFEXPORT(WdfTimerGetParentObject),
6815
-
WDFEXPORT(WdfUsbTargetDeviceCreate),
6816
-
WDFEXPORT(WdfUsbTargetDeviceRetrieveInformation),
6817
-
WDFEXPORT(WdfUsbTargetDeviceGetDeviceDescriptor),
6818
-
WDFEXPORT(WdfUsbTargetDeviceRetrieveConfigDescriptor),
6819
-
WDFEXPORT(WdfUsbTargetDeviceQueryString),
6820
-
WDFEXPORT(WdfUsbTargetDeviceAllocAndQueryString),
6821
-
WDFEXPORT(WdfUsbTargetDeviceFormatRequestForString),
6822
-
WDFEXPORT(WdfUsbTargetDeviceGetNumInterfaces),
6823
-
WDFEXPORT(WdfUsbTargetDeviceSelectConfig),
6824
-
WDFEXPORT(WdfUsbTargetDeviceWdmGetConfigurationHandle),
6825
-
WDFEXPORT(WdfUsbTargetDeviceRetrieveCurrentFrameNumber),
6826
-
WDFEXPORT(WdfUsbTargetDeviceSendControlTransferSynchronously),
6827
-
WDFEXPORT(WdfUsbTargetDeviceFormatRequestForControlTransfer),
6828
-
WDFEXPORT(WdfUsbTargetDeviceIsConnectedSynchronous),
6829
-
WDFEXPORT(WdfUsbTargetDeviceResetPortSynchronously),
6830
-
WDFEXPORT(WdfUsbTargetDeviceCyclePortSynchronously),
6831
-
WDFEXPORT(WdfUsbTargetDeviceFormatRequestForCyclePort),
6832
-
WDFEXPORT(WdfUsbTargetDeviceSendUrbSynchronously),
6833
-
WDFEXPORT(WdfUsbTargetDeviceFormatRequestForUrb),
6834
-
WDFEXPORT(WdfUsbTargetPipeGetInformation),
6835
-
WDFEXPORT(WdfUsbTargetPipeIsInEndpoint),
6836
-
WDFEXPORT(WdfUsbTargetPipeIsOutEndpoint),
6837
-
WDFEXPORT(WdfUsbTargetPipeGetType),
6838
-
WDFEXPORT(WdfUsbTargetPipeSetNoMaximumPacketSizeCheck),
6839
-
WDFEXPORT(WdfUsbTargetPipeWriteSynchronously),
6840
-
WDFEXPORT(WdfUsbTargetPipeFormatRequestForWrite),
6841
-
WDFEXPORT(WdfUsbTargetPipeReadSynchronously),
6842
-
WDFEXPORT(WdfUsbTargetPipeFormatRequestForRead),
6843
-
WDFEXPORT(WdfUsbTargetPipeConfigContinuousReader),
6844
-
WDFEXPORT(WdfUsbTargetPipeAbortSynchronously),
6845
-
WDFEXPORT(WdfUsbTargetPipeFormatRequestForAbort),
6846
-
WDFEXPORT(WdfUsbTargetPipeResetSynchronously),
6847
-
WDFEXPORT(WdfUsbTargetPipeFormatRequestForReset),
6848
-
WDFEXPORT(WdfUsbTargetPipeSendUrbSynchronously),
6849
-
WDFEXPORT(WdfUsbTargetPipeFormatRequestForUrb),
6850
-
WDFEXPORT(WdfUsbInterfaceGetInterfaceNumber),
6851
-
WDFEXPORT(WdfUsbInterfaceGetNumEndpoints),
6852
-
WDFEXPORT(WdfUsbInterfaceGetDescriptor),
6853
-
WDFEXPORT(WdfUsbInterfaceSelectSetting),
6854
-
WDFEXPORT(WdfUsbInterfaceGetEndpointInformation),
6855
-
WDFEXPORT(WdfUsbTargetDeviceGetInterface),
6856
-
WDFEXPORT(WdfUsbInterfaceGetConfiguredSettingIndex),
6857
-
WDFEXPORT(WdfUsbInterfaceGetNumConfiguredPipes),
6858
-
WDFEXPORT(WdfUsbInterfaceGetConfiguredPipe),
6859
-
WDFEXPORT(WdfUsbTargetPipeWdmGetPipeHandle),
6860
-
WDFEXPORT(WdfVerifierDbgBreakPoint),
6861
-
WDFEXPORT(WdfVerifierKeBugCheck),
6862
-
WDFEXPORT(WdfWmiProviderCreate),
6863
-
WDFEXPORT(WdfWmiProviderGetDevice),
6864
-
WDFEXPORT(WdfWmiProviderIsEnabled),
6865
-
WDFEXPORT(WdfWmiProviderGetTracingHandle),
6866
-
WDFEXPORT(WdfWmiInstanceCreate),
6867
-
WDFEXPORT(WdfWmiInstanceRegister),
6868
-
WDFEXPORT(WdfWmiInstanceDeregister),
6869
-
WDFEXPORT(WdfWmiInstanceGetDevice),
6870
-
WDFEXPORT(WdfWmiInstanceGetProvider),
6871
-
WDFEXPORT(WdfWmiInstanceFireEvent),
7478
+
// WDFEXPORT(WdfUsbTargetDeviceCreate),
7479
+
// WDFEXPORT(WdfUsbTargetDeviceRetrieveInformation),
7480
+
// WDFEXPORT(WdfUsbTargetDeviceGetDeviceDescriptor),
7481
+
// WDFEXPORT(WdfUsbTargetDeviceRetrieveConfigDescriptor),
7482
+
// WDFEXPORT(WdfUsbTargetDeviceQueryString),
7483
+
// WDFEXPORT(WdfUsbTargetDeviceAllocAndQueryString),
7484
+
// WDFEXPORT(WdfUsbTargetDeviceFormatRequestForString),
7485
+
// WDFEXPORT(WdfUsbTargetDeviceGetNumInterfaces),
7486
+
// WDFEXPORT(WdfUsbTargetDeviceSelectConfig),
7487
+
// WDFEXPORT(WdfUsbTargetDeviceWdmGetConfigurationHandle),
7488
+
// WDFEXPORT(WdfUsbTargetDeviceRetrieveCurrentFrameNumber),
7489
+
// WDFEXPORT(WdfUsbTargetDeviceSendControlTransferSynchronously),
7490
+
// WDFEXPORT(WdfUsbTargetDeviceFormatRequestForControlTransfer),
7491
+
// WDFEXPORT(WdfUsbTargetDeviceIsConnectedSynchronous),
7492
+
// WDFEXPORT(WdfUsbTargetDeviceResetPortSynchronously),
7493
+
// WDFEXPORT(WdfUsbTargetDeviceCyclePortSynchronously),
7494
+
// WDFEXPORT(WdfUsbTargetDeviceFormatRequestForCyclePort),
7495
+
// WDFEXPORT(WdfUsbTargetDeviceSendUrbSynchronously),
7496
+
// WDFEXPORT(WdfUsbTargetDeviceFormatRequestForUrb),
7497
+
// WDFEXPORT(WdfUsbTargetPipeGetInformation),
7498
+
// WDFEXPORT(WdfUsbTargetPipeIsInEndpoint),
7499
+
// WDFEXPORT(WdfUsbTargetPipeIsOutEndpoint),
7500
+
// WDFEXPORT(WdfUsbTargetPipeGetType),
7501
+
// WDFEXPORT(WdfUsbTargetPipeSetNoMaximumPacketSizeCheck),
7502
+
// WDFEXPORT(WdfUsbTargetPipeWriteSynchronously),
7503
+
// WDFEXPORT(WdfUsbTargetPipeFormatRequestForWrite),
7504
+
// WDFEXPORT(WdfUsbTargetPipeReadSynchronously),
7505
+
// WDFEXPORT(WdfUsbTargetPipeFormatRequestForRead),
7506
+
// WDFEXPORT(WdfUsbTargetPipeConfigContinuousReader),
7507
+
// WDFEXPORT(WdfUsbTargetPipeAbortSynchronously),
7508
+
// WDFEXPORT(WdfUsbTargetPipeFormatRequestForAbort),
7509
+
// WDFEXPORT(WdfUsbTargetPipeResetSynchronously),
7510
+
// WDFEXPORT(WdfUsbTargetPipeFormatRequestForReset),
7511
+
// WDFEXPORT(WdfUsbTargetPipeSendUrbSynchronously),
7512
+
// WDFEXPORT(WdfUsbTargetPipeFormatRequestForUrb),
7513
+
// WDFEXPORT(WdfUsbInterfaceGetInterfaceNumber),
7514
+
// WDFEXPORT(WdfUsbInterfaceGetNumEndpoints),
7515
+
// WDFEXPORT(WdfUsbInterfaceGetDescriptor),
7516
+
// WDFEXPORT(WdfUsbInterfaceSelectSetting),
7517
+
// WDFEXPORT(WdfUsbInterfaceGetEndpointInformation),
7518
+
// WDFEXPORT(WdfUsbTargetDeviceGetInterface),
7519
+
// WDFEXPORT(WdfUsbInterfaceGetConfiguredSettingIndex),
7520
+
// WDFEXPORT(WdfUsbInterfaceGetNumConfiguredPipes),
7521
+
// WDFEXPORT(WdfUsbInterfaceGetConfiguredPipe),
7522
+
// WDFEXPORT(WdfUsbTargetPipeWdmGetPipeHandle),
7523
+
// WDFEXPORT(WdfVerifierDbgBreakPoint),
7524
+
// WDFEXPORT(WdfVerifierKeBugCheck),
7525
+
// WDFEXPORT(WdfWmiProviderCreate),
7526
+
// WDFEXPORT(WdfWmiProviderGetDevice),
7527
+
// WDFEXPORT(WdfWmiProviderIsEnabled),
7528
+
// WDFEXPORT(WdfWmiProviderGetTracingHandle),
7529
+
// WDFEXPORT(WdfWmiInstanceCreate),
7530
+
// WDFEXPORT(WdfWmiInstanceRegister),
7531
+
// WDFEXPORT(WdfWmiInstanceDeregister),
7532
+
// WDFEXPORT(WdfWmiInstanceGetDevice),
7533
+
// WDFEXPORT(WdfWmiInstanceGetProvider),
7534
+
// WDFEXPORT(WdfWmiInstanceFireEvent),
7535
+
WdfApiNotImplemented,
7536
+
WdfApiNotImplemented,
7537
+
WdfApiNotImplemented,
7538
+
WdfApiNotImplemented,
7539
+
WdfApiNotImplemented,
7540
+
WdfApiNotImplemented,
7541
+
WdfApiNotImplemented,
7542
+
WdfApiNotImplemented,
7543
+
WdfApiNotImplemented,
7544
+
WdfApiNotImplemented,
7545
+
WdfApiNotImplemented,
7546
+
WdfApiNotImplemented,
7547
+
WdfApiNotImplemented,
7548
+
WdfApiNotImplemented,
7549
+
WdfApiNotImplemented,
7550
+
WdfApiNotImplemented,
7551
+
WdfApiNotImplemented,
7552
+
WdfApiNotImplemented,
7553
+
WdfApiNotImplemented,
7554
+
WdfApiNotImplemented,
7555
+
WdfApiNotImplemented,
7556
+
WdfApiNotImplemented,
7557
+
WdfApiNotImplemented,
7558
+
WdfApiNotImplemented,
7559
+
WdfApiNotImplemented,
7560
+
WdfApiNotImplemented,
7561
+
WdfApiNotImplemented,
7562
+
WdfApiNotImplemented,
7563
+
WdfApiNotImplemented,
7564
+
WdfApiNotImplemented,
7565
+
WdfApiNotImplemented,
7566
+
WdfApiNotImplemented,
7567
+
WdfApiNotImplemented,
7568
+
WdfApiNotImplemented,
7569
+
WdfApiNotImplemented,
7570
+
WdfApiNotImplemented,
7571
+
WdfApiNotImplemented,
7572
+
WdfApiNotImplemented,
7573
+
WdfApiNotImplemented,
7574
+
WdfApiNotImplemented,
7575
+
WdfApiNotImplemented,
7576
+
WdfApiNotImplemented,
7577
+
WdfApiNotImplemented,
7578
+
WdfApiNotImplemented,
7579
+
WdfApiNotImplemented,
7580
+
WdfApiNotImplemented,
7581
+
WdfApiNotImplemented,
7582
+
WdfApiNotImplemented,
7583
+
WdfApiNotImplemented,
7584
+
WdfApiNotImplemented,
7585
+
WdfApiNotImplemented,
7586
+
WdfApiNotImplemented,
7587
+
WdfApiNotImplemented,
7588
+
WdfApiNotImplemented,
7589
+
WdfApiNotImplemented,
7590
+
WdfApiNotImplemented,
7591
+
WdfApiNotImplemented,
7592
+
6872
7593
WDFEXPORT(WdfWorkItemCreate),
6873
7594
WDFEXPORT(WdfWorkItemEnqueue),
6874
7595
WDFEXPORT(WdfWorkItemGetParentObject),
6875
7596
WDFEXPORT(WdfWorkItemFlush),
6876
-
WDFEXPORT(WdfCommonBufferCreateWithConfig),
6877
-
WDFEXPORT(WdfDmaEnablerGetFragmentLength),
6878
-
WDFEXPORT(WdfDmaEnablerWdmGetDmaAdapter),
6879
-
WDFEXPORT(WdfUsbInterfaceGetNumSettings),
7597
+
// WDFEXPORT(WdfCommonBufferCreateWithConfig),
7598
+
// WDFEXPORT(WdfDmaEnablerGetFragmentLength),
7599
+
// WDFEXPORT(WdfDmaEnablerWdmGetDmaAdapter),
7600
+
// WDFEXPORT(WdfUsbInterfaceGetNumSettings),
7601
+
WdfApiNotImplemented,
7602
+
WdfApiNotImplemented,
7603
+
WdfApiNotImplemented,
7604
+
WdfApiNotImplemented,
7605
+
6880
7606
WDFEXPORT(WdfDeviceRemoveDependentUsageDeviceObject),
6881
7607
WDFEXPORT(WdfDeviceGetSystemPowerAction),
6882
-
WDFEXPORT(WdfInterruptSetExtendedPolicy),
7608
+
// WDFEXPORT(WdfInterruptSetExtendedPolicy),
7609
+
WdfApiNotImplemented,
7610
+
6883
7611
WDFEXPORT(WdfIoQueueAssignForwardProgressPolicy),
6884
7612
WDFEXPORT(WdfPdoInitAssignContainerID),
6885
7613
WDFEXPORT(WdfPdoInitAllowForwardingRequestToParent),
6886
7614
WDFEXPORT(WdfRequestMarkCancelableEx),
6887
7615
WDFEXPORT(WdfRequestIsReserved),
6888
7616
WDFEXPORT(WdfRequestForwardToParentDeviceIoQueue),
6889
-
WDFEXPORT(WdfCxDeviceInitAllocate),
6890
-
WDFEXPORT(WdfCxDeviceInitAssignWdmIrpPreprocessCallback),
6891
-
WDFEXPORT(WdfCxDeviceInitSetIoInCallerContextCallback),
6892
-
WDFEXPORT(WdfCxDeviceInitSetRequestAttributes),
6893
-
WDFEXPORT(WdfCxDeviceInitSetFileObjectConfig),
7617
+
// WDFEXPORT(WdfCxDeviceInitAllocate),
7618
+
// WDFEXPORT(WdfCxDeviceInitAssignWdmIrpPreprocessCallback),
7619
+
// WDFEXPORT(WdfCxDeviceInitSetIoInCallerContextCallback),
7620
+
// WDFEXPORT(WdfCxDeviceInitSetRequestAttributes),
7621
+
// WDFEXPORT(WdfCxDeviceInitSetFileObjectConfig),
7622
+
WdfApiNotImplemented,
7623
+
WdfApiNotImplemented,
7624
+
WdfApiNotImplemented,
7625
+
WdfApiNotImplemented,
7626
+
WdfApiNotImplemented,
7627
+
6894
7628
WDFEXPORT(WdfDeviceWdmDispatchIrp),
6895
7629
WDFEXPORT(WdfDeviceWdmDispatchIrpToIoQueue),
6896
7630
WDFEXPORT(WdfDeviceInitSetRemoveLockOptions),
6897
7631
WDFEXPORT(WdfDeviceConfigureWdmIrpDispatchCallback),
6898
-
WDFEXPORT(WdfDmaEnablerConfigureSystemProfile),
6899
-
WDFEXPORT(WdfDmaTransactionInitializeUsingOffset),
6900
-
WDFEXPORT(WdfDmaTransactionGetTransferInfo),
6901
-
WDFEXPORT(WdfDmaTransactionSetChannelConfigurationCallback),
6902
-
WDFEXPORT(WdfDmaTransactionSetTransferCompleteCallback),
6903
-
WDFEXPORT(WdfDmaTransactionSetImmediateExecution),
6904
-
WDFEXPORT(WdfDmaTransactionAllocateResources),
6905
-
WDFEXPORT(WdfDmaTransactionSetDeviceAddressOffset),
6906
-
WDFEXPORT(WdfDmaTransactionFreeResources),
6907
-
WDFEXPORT(WdfDmaTransactionCancel),
6908
-
WDFEXPORT(WdfDmaTransactionWdmGetTransferContext),
6909
-
WDFEXPORT(WdfInterruptQueueWorkItemForIsr),
6910
-
WDFEXPORT(WdfInterruptTryToAcquireLock),
7632
+
// WDFEXPORT(WdfDmaEnablerConfigureSystemProfile),
7633
+
// WDFEXPORT(WdfDmaTransactionInitializeUsingOffset),
7634
+
// WDFEXPORT(WdfDmaTransactionGetTransferInfo),
7635
+
// WDFEXPORT(WdfDmaTransactionSetChannelConfigurationCallback),
7636
+
// WDFEXPORT(WdfDmaTransactionSetTransferCompleteCallback),
7637
+
// WDFEXPORT(WdfDmaTransactionSetImmediateExecution),
7638
+
// WDFEXPORT(WdfDmaTransactionAllocateResources),
7639
+
// WDFEXPORT(WdfDmaTransactionSetDeviceAddressOffset),
7640
+
// WDFEXPORT(WdfDmaTransactionFreeResources),
7641
+
// WDFEXPORT(WdfDmaTransactionCancel),
7642
+
// WDFEXPORT(WdfDmaTransactionWdmGetTransferContext),
7643
+
// WDFEXPORT(WdfInterruptQueueWorkItemForIsr),
7644
+
// WDFEXPORT(WdfInterruptTryToAcquireLock),
7645
+
WdfApiNotImplemented,
7646
+
WdfApiNotImplemented,
7647
+
WdfApiNotImplemented,
7648
+
WdfApiNotImplemented,
7649
+
WdfApiNotImplemented,
7650
+
WdfApiNotImplemented,
7651
+
WdfApiNotImplemented,
7652
+
WdfApiNotImplemented,
7653
+
WdfApiNotImplemented,
7654
+
WdfApiNotImplemented,
7655
+
WdfApiNotImplemented,
7656
+
WdfApiNotImplemented,
7657
+
WdfApiNotImplemented,
7658
+
6911
7659
WDFEXPORT(WdfIoQueueStopAndPurge),
6912
7660
WDFEXPORT(WdfIoQueueStopAndPurgeSynchronously),
6913
7661
WDFEXPORT(WdfIoTargetPurge),
6914
-
WDFEXPORT(WdfUsbTargetDeviceCreateWithParameters),
6915
-
WDFEXPORT(WdfUsbTargetDeviceQueryUsbCapability),
6916
-
WDFEXPORT(WdfUsbTargetDeviceCreateUrb),
6917
-
WDFEXPORT(WdfUsbTargetDeviceCreateIsochUrb),
7662
+
// WDFEXPORT(WdfUsbTargetDeviceCreateWithParameters),
7663
+
// WDFEXPORT(WdfUsbTargetDeviceQueryUsbCapability),
7664
+
// WDFEXPORT(WdfUsbTargetDeviceCreateUrb),
7665
+
// WDFEXPORT(WdfUsbTargetDeviceCreateIsochUrb),
7666
+
WdfApiNotImplemented,
7667
+
WdfApiNotImplemented,
7668
+
WdfApiNotImplemented,
7669
+
WdfApiNotImplemented,
7670
+
6918
7671
WDFEXPORT(WdfDeviceWdmAssignPowerFrameworkSettings),
6919
-
WDFEXPORT(WdfDmaTransactionStopSystemTransfer),
6920
-
WDFEXPORT(WdfCxVerifierKeBugCheck),
6921
-
WDFEXPORT(WdfInterruptReportActive),
6922
-
WDFEXPORT(WdfInterruptReportInactive),
7672
+
// WDFEXPORT(WdfDmaTransactionStopSystemTransfer),
7673
+
// WDFEXPORT(WdfCxVerifierKeBugCheck),
7674
+
// WDFEXPORT(WdfInterruptReportActive),
7675
+
// WDFEXPORT(WdfInterruptReportInactive),
7676
+
WdfApiNotImplemented,
7677
+
WdfApiNotImplemented,
7678
+
WdfApiNotImplemented,
7679
+
WdfApiNotImplemented,
7680
+
6923
7681
WDFEXPORT(WdfDeviceInitSetReleaseHardwareOrderOnFailure),
6924
-
WDFEXPORT(WdfGetTriageInfo),
7682
+
// WDFEXPORT(WdfGetTriageInfo),
7683
+
WdfApiNotImplemented,
7684
+
6925
7685
WDFEXPORT(WdfDeviceInitSetIoTypeEx),
6926
7686
WDFEXPORT(WdfDeviceQueryPropertyEx),
6927
7687
WDFEXPORT(WdfDeviceAllocAndQueryPropertyEx),
+2
-4
sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamicswrapper.h
+2
-4
sdk/lib/drivers/wdf/kmdf/inc/private/fxdynamicswrapper.h
···
7
7
//
8
8
9
9
extern "C" {
10
-
#pragma warning(disable:4200) // zero-sized array in struct/union
11
10
#include <usbdrivr.h>
12
-
#pragma warning(default:4200)
13
11
14
12
#include <wdfusb.h>
15
13
#include <wdfminiport.h>
16
-
#include "FxDynamics.h"
17
-
#include "VfFxDynamics.h"
14
+
#include "fxdynamics.h"
15
+
#include "vffxdynamics.h"
18
16
}
+1
-1
sdk/lib/drivers/wdf/kmdf/inc/private/fxprobeandlock.h
+1
-1
sdk/lib/drivers/wdf/kmdf/inc/private/fxprobeandlock.h
+137
-146
sdk/lib/drivers/wdf/kmdf/src/core/fxbugcheckcallback.cpp
+137
-146
sdk/lib/drivers/wdf/kmdf/src/core/fxbugcheckcallback.cpp
···
20
20
21
21
22
22
#include "fxcorepch.hpp"
23
-
#include "FxIFR.h"
24
-
#include "fxIFRKm.h" // kernel mode only IFR definitions
25
-
#include "FxLdr.h"
26
-
#include "FxBugcheck.h"
23
+
#include "fxifr.h"
24
+
#include "fxifrkm.h" // kernel mode only IFR definitions
25
+
#include "fxldr.h"
26
+
#include "fxbugcheck.h"
27
27
28
-
#include <aux_klib.h>
28
+
// #include <aux_klib.h>
29
29
30
30
//
31
31
// Disable warnings of features used by the standard headers
···
35
35
// Disable warning C4201: nonstandard extension used : nameless struct/union
36
36
// Disable warning C4214: nonstandard extension used : bit field types other than int
37
37
//
38
-
#pragma warning(disable:4115 4200 4201 4214)
38
+
// #pragma warning(disable:4115 4200 4201 4214)
39
39
#include <ntimage.h>
40
-
#pragma warning(default:4115 4200 4201 4214)
40
+
// #pragma warning(default:4115 4200 4201 4214)
41
41
42
42
43
43
extern "C" {
···
125
125
__out PULONG ImageSize
126
126
)
127
127
{
128
-
NTSTATUS status = STATUS_UNSUCCESSFUL;
129
-
ULONG modulesSize = 0;
130
-
AUX_MODULE_EXTENDED_INFO* modules = NULL;
131
-
AUX_MODULE_EXTENDED_INFO* module;
132
-
PVOID addressInImage = NULL;
133
-
ULONG numberOfModules;
134
-
ULONG i;
128
+
// NTSTATUS status = STATUS_UNSUCCESSFUL;
129
+
// ULONG modulesSize = 0;
130
+
// AUX_MODULE_EXTENDED_INFO* modules = NULL;
131
+
// AUX_MODULE_EXTENDED_INFO* module;
132
+
// PVOID addressInImage = NULL;
133
+
// ULONG numberOfModules;
134
+
// ULONG i;
135
135
136
-
//
137
-
// Basic validation.
138
-
//
139
-
if (NULL == DriverObject || NULL == ImageBase || NULL == ImageSize) {
140
-
status = STATUS_INVALID_PARAMETER;
141
-
goto exit;
142
-
}
136
+
// //
137
+
// // Basic validation.
138
+
// //
139
+
// if (NULL == DriverObject || NULL == ImageBase || NULL == ImageSize) {
140
+
// status = STATUS_INVALID_PARAMETER;
141
+
// goto exit;
142
+
// }
143
143
144
-
//
145
-
// Get the address of a well known entry in the Image.
146
-
//
147
-
addressInImage = (PVOID) DriverObject->DriverStart;
148
-
ASSERT(addressInImage != NULL);
144
+
// //
145
+
// // Get the address of a well known entry in the Image.
146
+
// //
147
+
// addressInImage = (PVOID) DriverObject->DriverStart;
148
+
// ASSERT(addressInImage != NULL);
149
149
150
-
//
151
-
// Initialize the AUX Kernel Library.
152
-
//
153
-
status = AuxKlibInitialize();
154
-
if (!NT_SUCCESS(status)) {
155
-
goto exit;
156
-
}
150
+
// //
151
+
// // Initialize the AUX Kernel Library.
152
+
// //
153
+
// status = AuxKlibInitialize();
154
+
// if (!NT_SUCCESS(status)) {
155
+
// goto exit;
156
+
// }
157
157
158
-
//
159
-
// Get size of area needed for loaded modules.
160
-
//
161
-
status = AuxKlibQueryModuleInformation(&modulesSize,
162
-
sizeof(AUX_MODULE_EXTENDED_INFO),
163
-
NULL);
158
+
// //
159
+
// // Get size of area needed for loaded modules.
160
+
// //
161
+
// status = AuxKlibQueryModuleInformation(&modulesSize,
162
+
// sizeof(AUX_MODULE_EXTENDED_INFO),
163
+
// NULL);
164
164
165
-
if (!NT_SUCCESS(status) || (0 == modulesSize)) {
166
-
goto exit;
167
-
}
165
+
// if (!NT_SUCCESS(status) || (0 == modulesSize)) {
166
+
// goto exit;
167
+
// }
168
168
169
-
numberOfModules = modulesSize / sizeof(AUX_MODULE_EXTENDED_INFO);
169
+
// numberOfModules = modulesSize / sizeof(AUX_MODULE_EXTENDED_INFO);
170
170
171
-
//
172
-
// Allocate returned-sized memory for the modules area.
173
-
//
174
-
modules = (AUX_MODULE_EXTENDED_INFO*) ExAllocatePoolWithTag(PagedPool,
175
-
modulesSize,
176
-
'30LW');
177
-
if (NULL == modules) {
178
-
status = STATUS_INSUFFICIENT_RESOURCES;
179
-
goto exit;
180
-
}
171
+
// //
172
+
// // Allocate returned-sized memory for the modules area.
173
+
// //
174
+
// modules = (AUX_MODULE_EXTENDED_INFO*) ExAllocatePoolWithTag(PagedPool,
175
+
// modulesSize,
176
+
// '30LW');
177
+
// if (NULL == modules) {
178
+
// status = STATUS_INSUFFICIENT_RESOURCES;
179
+
// goto exit;
180
+
// }
181
181
182
-
//
183
-
// Request the modules array be filled with module information.
184
-
//
185
-
status = AuxKlibQueryModuleInformation(&modulesSize,
186
-
sizeof(AUX_MODULE_EXTENDED_INFO),
187
-
modules);
182
+
// //
183
+
// // Request the modules array be filled with module information.
184
+
// //
185
+
// status = AuxKlibQueryModuleInformation(&modulesSize,
186
+
// sizeof(AUX_MODULE_EXTENDED_INFO),
187
+
// modules);
188
188
189
-
if (!NT_SUCCESS(status)) {
190
-
goto exit;
191
-
}
189
+
// if (!NT_SUCCESS(status)) {
190
+
// goto exit;
191
+
// }
192
192
193
-
//
194
-
// Traverse list, searching for the well known address in Image for which the
195
-
// module's Image Base Address is in its range.
196
-
//
197
-
module = modules;
193
+
// //
194
+
// // Traverse list, searching for the well known address in Image for which the
195
+
// // module's Image Base Address is in its range.
196
+
// //
197
+
// module = modules;
198
198
199
-
for (i=0; i < numberOfModules; i++) {
199
+
// for (i=0; i < numberOfModules; i++) {
200
200
201
-
if (addressInImage >= module->BasicInfo.ImageBase &&
202
-
addressInImage < WDF_PTR_ADD_OFFSET(module->BasicInfo.ImageBase,
203
-
module->ImageSize)) {
201
+
// if (addressInImage >= module->BasicInfo.ImageBase &&
202
+
// addressInImage < WDF_PTR_ADD_OFFSET(module->BasicInfo.ImageBase,
203
+
// module->ImageSize)) {
204
204
205
-
*ImageBase = module->BasicInfo.ImageBase;
206
-
*ImageSize = module->ImageSize;
205
+
// *ImageBase = module->BasicInfo.ImageBase;
206
+
// *ImageSize = module->ImageSize;
207
207
208
-
status = STATUS_SUCCESS;
209
-
goto exit;
210
-
}
211
-
module++;
212
-
}
208
+
// status = STATUS_SUCCESS;
209
+
// goto exit;
210
+
// }
211
+
// module++;
212
+
// }
213
213
214
-
status = STATUS_NOT_FOUND;
214
+
// status = STATUS_NOT_FOUND;
215
215
216
-
exit:
216
+
// exit:
217
217
218
-
if (modules != NULL) {
219
-
ExFreePool(modules);
220
-
modules = NULL;
221
-
}
218
+
// if (modules != NULL) {
219
+
// ExFreePool(modules);
220
+
// modules = NULL;
221
+
// }
222
222
223
-
return status;
223
+
// return status;
224
+
ROSWDFNOTIMPLEMENTED;
225
+
return STATUS_NOT_IMPLEMENTED;
224
226
}
225
227
226
228
_Must_inspect_result_
···
246
248
247
249
--*/
248
250
{
249
-
PVOID codeAddr = NULL;
250
-
BOOLEAN found = FALSE;
251
-
KBUGCHECK_DATA bugCheckData = {0};
252
-
253
-
if (FxDriverGlobals->FxForceLogsInMiniDump) {
254
-
return TRUE;
255
-
}
256
-
257
-
//
258
-
// Retrieve the bugcheck parameters.
259
-
//
260
-
bugCheckData.BugCheckDataSize = sizeof(KBUGCHECK_DATA);
261
-
AuxKlibGetBugCheckData(&bugCheckData);
262
-
263
-
//
264
-
// Check whether the code address that caused the bugcheck is from this wdf
265
-
// driver.
266
-
//
267
-
switch (bugCheckData.BugCheckCode) {
268
-
269
-
case KERNEL_APC_PENDING_DURING_EXIT: // 0x20
270
-
codeAddr = (PVOID)bugCheckData.Parameter1;
271
-
found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
272
-
break;
273
-
274
-
case KMODE_EXCEPTION_NOT_HANDLED: // 0x1E
275
-
case SYSTEM_THREAD_EXCEPTION_NOT_HANDLED: // 0x7E
276
-
case KERNEL_MODE_EXCEPTION_NOT_HANDLED: // 0x8E
277
-
codeAddr = (PVOID)bugCheckData.Parameter2;
278
-
found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
279
-
break;
280
-
281
-
case PAGE_FAULT_IN_NONPAGED_AREA: // 0x50
282
-
codeAddr = (PVOID)bugCheckData.Parameter3;
283
-
found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
284
-
break;
285
-
286
-
case IRQL_NOT_LESS_OR_EQUAL: // 0xA
287
-
case DRIVER_IRQL_NOT_LESS_OR_EQUAL: // 0xD1
288
-
codeAddr = (PVOID)bugCheckData.Parameter4;
289
-
found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
290
-
break;
291
-
}
251
+
// PVOID codeAddr = NULL;
252
+
// BOOLEAN found = FALSE;
253
+
// KBUGCHECK_DATA bugCheckData = {0};
292
254
293
-
//
294
-
// If the code address was found in the wdf driver, then set the flag in the
295
-
// driver globals to indicate that the IFR data has to be written to the
296
-
// mini-dump.
297
-
//
298
-
if (found) {
299
-
FxDriverGlobals->FxForceLogsInMiniDump = TRUE;
300
-
}
255
+
// if (FxDriverGlobals->FxForceLogsInMiniDump) {
256
+
// return TRUE;
257
+
// }
301
258
259
+
// //
260
+
// // Retrieve the bugcheck parameters.
261
+
// //
262
+
// bugCheckData.BugCheckDataSize = sizeof(KBUGCHECK_DATA);
263
+
// AuxKlibGetBugCheckData(&bugCheckData);
302
264
265
+
// //
266
+
// // Check whether the code address that caused the bugcheck is from this wdf
267
+
// // driver.
268
+
// //
269
+
// switch (bugCheckData.BugCheckCode) {
303
270
271
+
// case KERNEL_APC_PENDING_DURING_EXIT: // 0x20
272
+
// codeAddr = (PVOID)bugCheckData.Parameter1;
273
+
// found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
274
+
// break;
304
275
276
+
// case KMODE_EXCEPTION_NOT_HANDLED: // 0x1E
277
+
// case SYSTEM_THREAD_EXCEPTION_NOT_HANDLED: // 0x7E
278
+
// case KERNEL_MODE_EXCEPTION_NOT_HANDLED: // 0x8E
279
+
// codeAddr = (PVOID)bugCheckData.Parameter2;
280
+
// found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
281
+
// break;
305
282
283
+
// case PAGE_FAULT_IN_NONPAGED_AREA: // 0x50
284
+
// codeAddr = (PVOID)bugCheckData.Parameter3;
285
+
// found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
286
+
// break;
306
287
307
-
308
-
309
-
310
-
311
-
312
-
313
-
314
-
288
+
// case IRQL_NOT_LESS_OR_EQUAL: // 0xA
289
+
// case DRIVER_IRQL_NOT_LESS_OR_EQUAL: // 0xD1
290
+
// codeAddr = (PVOID)bugCheckData.Parameter4;
291
+
// found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
292
+
// break;
293
+
// }
315
294
316
-
return found;
295
+
// //
296
+
// // If the code address was found in the wdf driver, then set the flag in the
297
+
// // driver globals to indicate that the IFR data has to be written to the
298
+
// // mini-dump.
299
+
// //
300
+
// if (found) {
301
+
// FxDriverGlobals->FxForceLogsInMiniDump = TRUE;
302
+
// }
303
+
// return found;
304
+
ROSWDFNOTIMPLEMENTED;
305
+
return FALSE;
317
306
}
318
307
319
308
VOID
309
+
STDCALL
320
310
FxpBugCheckCallback(
321
311
__in KBUGCHECK_CALLBACK_REASON Reason,
322
312
__in PKBUGCHECK_REASON_CALLBACK_RECORD Record,
···
567
557
}
568
558
569
559
VOID
560
+
STDCALL
570
561
FxpLibraryBugCheckCallback(
571
562
__in KBUGCHECK_CALLBACK_REASON Reason,
572
563
__in PKBUGCHECK_REASON_CALLBACK_RECORD /* Record */,
···
1043
1034
//
1044
1035
// Intialize the procgrp down level library.
1045
1036
//
1046
-
WdmlibProcgrpInitialize();
1037
+
// WdmlibProcgrpInitialize(); __REACTOS__ : haha we don't support ProcGrp
1047
1038
1048
1039
//
1049
1040
// Capture maximum number of processors.
+1
-4
sdk/lib/drivers/wdf/kmdf/src/core/fxchildlist.cpp
+1
-4
sdk/lib/drivers/wdf/kmdf/src/core/fxchildlist.cpp
···
25
25
#include "fxcorepch.hpp"
26
26
27
27
extern "C" {
28
-
#include "FxChildList.tmh"
28
+
// #include "FxChildList.tmh"
29
29
}
30
30
31
31
FxDeviceDescriptionEntry::FxDeviceDescriptionEntry(
···
1145
1145
for (ple = m_ModificationListHead.Flink;
1146
1146
ple != &m_ModificationListHead;
1147
1147
ple = ple->Flink) {
1148
-
BOOLEAN check;
1149
-
1150
-
check = FALSE;
1151
1148
1152
1149
pEntry = FxDeviceDescriptionEntry::_FromModificationLink(ple);
1153
1150
+14
-1
sdk/lib/drivers/wdf/kmdf/src/core/fxchildlistapi.cpp
+14
-1
sdk/lib/drivers/wdf/kmdf/src/core/fxchildlistapi.cpp
···
25
25
#include "fxcorepch.hpp"
26
26
27
27
extern "C" {
28
-
#include "FxChildListAPI.tmh"
28
+
// #include "FxChildListAPI.tmh"
29
29
}
30
30
31
31
//
···
36
36
_Must_inspect_result_
37
37
__drv_maxIRQL(PASSIVE_LEVEL)
38
38
NTSTATUS
39
+
STDCALL
39
40
WDFEXPORT(WdfChildListCreate)(
40
41
__in
41
42
PWDF_DRIVER_GLOBALS DriverGlobals,
···
125
126
126
127
__drv_maxIRQL(DISPATCH_LEVEL)
127
128
WDFDEVICE
129
+
STDCALL
128
130
WDFEXPORT(WdfChildListGetDevice)(
129
131
__in
130
132
PWDF_DRIVER_GLOBALS DriverGlobals,
···
150
152
_Must_inspect_result_
151
153
__drv_maxIRQL(DISPATCH_LEVEL)
152
154
NTSTATUS
155
+
STDCALL
153
156
WDFEXPORT(WdfChildListRetrieveAddressDescription)(
154
157
__in
155
158
PWDF_DRIVER_GLOBALS DriverGlobals,
···
226
229
227
230
__drv_maxIRQL(DISPATCH_LEVEL)
228
231
VOID
232
+
STDCALL
229
233
WDFEXPORT(WdfChildListBeginScan)(
230
234
__in
231
235
PWDF_DRIVER_GLOBALS DriverGlobals,
···
250
254
251
255
__drv_maxIRQL(DISPATCH_LEVEL)
252
256
VOID
257
+
STDCALL
253
258
WDFEXPORT(WdfChildListEndScan)(
254
259
__in
255
260
PWDF_DRIVER_GLOBALS DriverGlobals,
···
274
279
275
280
__drv_maxIRQL(DISPATCH_LEVEL)
276
281
VOID
282
+
STDCALL
277
283
WDFEXPORT(WdfChildListBeginIteration)(
278
284
__in
279
285
PWDF_DRIVER_GLOBALS DriverGlobals,
···
323
329
_Must_inspect_result_
324
330
__drv_maxIRQL(DISPATCH_LEVEL)
325
331
NTSTATUS
332
+
STDCALL
326
333
WDFEXPORT(WdfChildListRetrieveNextDevice)(
327
334
__in
328
335
PWDF_DRIVER_GLOBALS DriverGlobals,
···
425
432
426
433
__drv_maxIRQL(DISPATCH_LEVEL)
427
434
VOID
435
+
STDCALL
428
436
WDFEXPORT(WdfChildListEndIteration)(
429
437
__in
430
438
PWDF_DRIVER_GLOBALS DriverGlobals,
···
473
481
_Must_inspect_result_
474
482
__drv_maxIRQL(DISPATCH_LEVEL)
475
483
NTSTATUS
484
+
STDCALL
476
485
WDFEXPORT(WdfChildListAddOrUpdateChildDescriptionAsPresent)(
477
486
__in
478
487
PWDF_DRIVER_GLOBALS DriverGlobals,
···
561
570
_Must_inspect_result_
562
571
__drv_maxIRQL(DISPATCH_LEVEL)
563
572
NTSTATUS
573
+
STDCALL
564
574
WDFEXPORT(WdfChildListUpdateChildDescriptionAsMissing)(
565
575
__in
566
576
PWDF_DRIVER_GLOBALS DriverGlobals,
···
609
619
610
620
__drv_maxIRQL(DISPATCH_LEVEL)
611
621
VOID
622
+
STDCALL
612
623
WDFEXPORT(WdfChildListUpdateAllChildDescriptionsAsPresent)(
613
624
__in
614
625
PWDF_DRIVER_GLOBALS DriverGlobals,
···
637
648
_Must_inspect_result_
638
649
__drv_maxIRQL(DISPATCH_LEVEL)
639
650
WDFDEVICE
651
+
STDCALL
640
652
WDFEXPORT(WdfChildListRetrievePdo)(
641
653
__in
642
654
PWDF_DRIVER_GLOBALS DriverGlobals,
···
734
746
735
747
__drv_maxIRQL(DISPATCH_LEVEL)
736
748
BOOLEAN
749
+
STDCALL
737
750
WDFEXPORT(WdfChildListRequestChildEject)(
738
751
__in
739
752
PWDF_DRIVER_GLOBALS DriverGlobals,
+7
-1
sdk/lib/drivers/wdf/kmdf/src/core/fxdevicefdoapi.cpp
+7
-1
sdk/lib/drivers/wdf/kmdf/src/core/fxdevicefdoapi.cpp
···
25
25
#include "fxcorepch.hpp"
26
26
27
27
extern "C" {
28
-
#include "FxDeviceFdoApi.tmh"
28
+
// #include "FxDeviceFdoApi.tmh"
29
29
}
30
30
31
31
//
···
36
36
_Must_inspect_result_
37
37
__drv_maxIRQL(DISPATCH_LEVEL)
38
38
NTSTATUS
39
+
STDCALL
39
40
WDFEXPORT(WdfFdoAddStaticChild)(
40
41
__in
41
42
PWDF_DRIVER_GLOBALS DriverGlobals,
···
121
122
122
123
__drv_maxIRQL(DISPATCH_LEVEL)
123
124
VOID
125
+
STDCALL
124
126
WDFEXPORT(WdfFdoLockStaticChildListForIteration)(
125
127
__in
126
128
PWDF_DRIVER_GLOBALS DriverGlobals,
···
179
181
_Must_inspect_result_
180
182
__drv_maxIRQL(DISPATCH_LEVEL)
181
183
WDFDEVICE
184
+
STDCALL
182
185
WDFEXPORT(WdfFdoRetrieveNextStaticChild)(
183
186
__in
184
187
PWDF_DRIVER_GLOBALS DriverGlobals,
···
256
259
257
260
__drv_maxIRQL(DISPATCH_LEVEL)
258
261
VOID
262
+
STDCALL
259
263
WDFEXPORT(WdfFdoUnlockStaticChildListFromIteration)(
260
264
__in
261
265
PWDF_DRIVER_GLOBALS DriverGlobals,
···
311
315
_Must_inspect_result_
312
316
__drv_maxIRQL(PASSIVE_LEVEL)
313
317
NTSTATUS
318
+
STDCALL
314
319
WDFEXPORT(WdfFdoQueryForInterface)(
315
320
__in
316
321
PWDF_DRIVER_GLOBALS DriverGlobals,
···
405
410
406
411
__drv_maxIRQL(DISPATCH_LEVEL)
407
412
WDFCHILDLIST
413
+
STDCALL
408
414
WDFEXPORT(WdfFdoGetDefaultChildList)(
409
415
__in
410
416
PWDF_DRIVER_GLOBALS DriverGlobals,
+19
-10
sdk/lib/drivers/wdf/kmdf/src/core/fxdevicepdoapi.cpp
+19
-10
sdk/lib/drivers/wdf/kmdf/src/core/fxdevicepdoapi.cpp
···
25
25
#include "fxcorepch.hpp"
26
26
27
27
extern "C" {
28
-
#include "FxDevicePdoApi.tmh"
28
+
// #include "FxDevicePdoApi.tmh"
29
29
}
30
30
31
31
NTSTATUS
···
87
87
_Must_inspect_result_
88
88
__drv_maxIRQL(DISPATCH_LEVEL)
89
89
NTSTATUS
90
+
STDCALL
90
91
WDFEXPORT(WdfPdoMarkMissing)(
91
92
__in
92
93
PWDF_DRIVER_GLOBALS DriverGlobals,
···
101
102
102
103
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
103
104
Device,
104
-
__FUNCTION__,
105
+
(PCHAR)__FUNCTION__,
105
106
&pPkgPdo,
106
107
&pFxDriverGlobals,
107
108
&pDevice);
···
120
121
__drv_maxIRQL(DISPATCH_LEVEL)
121
122
WDFAPI
122
123
VOID
124
+
STDCALL
123
125
WDFEXPORT(WdfPdoRequestEject)(
124
126
__in
125
127
PWDF_DRIVER_GLOBALS DriverGlobals,
···
134
136
135
137
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
136
138
Device,
137
-
__FUNCTION__,
139
+
(PCHAR)__FUNCTION__,
138
140
&pPkgPdo,
139
141
&pFxDriverGlobals,
140
142
&pDevice);
···
163
165
164
166
__drv_maxIRQL(DISPATCH_LEVEL)
165
167
WDFDEVICE
168
+
STDCALL
166
169
WDFEXPORT(WdfPdoGetParent)(
167
170
__in
168
171
PWDF_DRIVER_GLOBALS DriverGlobals,
···
177
180
178
181
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
179
182
Device,
180
-
__FUNCTION__,
183
+
(PCHAR)__FUNCTION__,
181
184
&pPkgPdo,
182
185
&pFxDriverGlobals,
183
186
&pDevice);
···
197
200
__drv_maxIRQL(DISPATCH_LEVEL)
198
201
WDFAPI
199
202
NTSTATUS
203
+
STDCALL
200
204
WDFEXPORT(WdfPdoRetrieveIdentificationDescription)(
201
205
__in
202
206
PWDF_DRIVER_GLOBALS DriverGlobals,
···
212
216
213
217
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
214
218
Device,
215
-
__FUNCTION__,
219
+
(PCHAR)__FUNCTION__,
216
220
&pPkgPdo,
217
221
&pFxDriverGlobals);
218
222
···
251
255
__drv_maxIRQL(DISPATCH_LEVEL)
252
256
WDFAPI
253
257
NTSTATUS
258
+
STDCALL
254
259
WDFEXPORT(WdfPdoRetrieveAddressDescription)(
255
260
__in
256
261
PWDF_DRIVER_GLOBALS DriverGlobals,
···
266
271
267
272
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
268
273
Device,
269
-
__FUNCTION__,
274
+
(PCHAR)__FUNCTION__,
270
275
&pPkgPdo,
271
276
&pFxDriverGlobals);
272
277
···
307
312
__drv_maxIRQL(DISPATCH_LEVEL)
308
313
WDFAPI
309
314
NTSTATUS
315
+
STDCALL
310
316
WDFEXPORT(WdfPdoUpdateAddressDescription)(
311
317
__in
312
318
PWDF_DRIVER_GLOBALS DriverGlobals,
···
322
328
323
329
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
324
330
Device,
325
-
__FUNCTION__,
331
+
(PCHAR)__FUNCTION__,
326
332
&pPkgPdo,
327
333
&pFxDriverGlobals);
328
334
···
354
360
_Must_inspect_result_
355
361
__drv_maxIRQL(DISPATCH_LEVEL)
356
362
NTSTATUS
363
+
STDCALL
357
364
WDFEXPORT(WdfPdoAddEjectionRelationsPhysicalDevice)(
358
365
__in
359
366
PWDF_DRIVER_GLOBALS DriverGlobals,
···
386
393
387
394
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
388
395
Device,
389
-
__FUNCTION__,
396
+
(PCHAR)__FUNCTION__,
390
397
&pPkgPdo,
391
398
&pFxDriverGlobals);
392
399
···
403
410
404
411
__drv_maxIRQL(DISPATCH_LEVEL)
405
412
VOID
413
+
STDCALL
406
414
WDFEXPORT(WdfPdoRemoveEjectionRelationsPhysicalDevice)(
407
415
__in
408
416
PWDF_DRIVER_GLOBALS DriverGlobals,
···
434
442
435
443
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
436
444
Device,
437
-
__FUNCTION__,
445
+
(PCHAR)__FUNCTION__,
438
446
&pPkgPdo,
439
447
&pFxDriverGlobals);
440
448
···
449
457
450
458
__drv_maxIRQL(DISPATCH_LEVEL)
451
459
VOID
460
+
STDCALL
452
461
WDFEXPORT(WdfPdoClearEjectionRelationsDevices)(
453
462
__in
454
463
PWDF_DRIVER_GLOBALS DriverGlobals,
···
476
485
477
486
status = GetPdoPackageFromDeviceHandle(GetFxDriverGlobals(DriverGlobals),
478
487
Device,
479
-
__FUNCTION__,
488
+
(PCHAR)__FUNCTION__,
480
489
&pPkgPdo,
481
490
&pFxDriverGlobals);
482
491
+2
-2
sdk/lib/drivers/wdf/kmdf/src/core/fxdpc.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/core/fxdpc.cpp
+7
-2
sdk/lib/drivers/wdf/kmdf/src/core/fxdpcapi.cpp
+7
-2
sdk/lib/drivers/wdf/kmdf/src/core/fxdpcapi.cpp
···
25
25
26
26
#include "fxcorepch.hpp"
27
27
28
-
#include "FxDpc.hpp"
28
+
#include "fxdpc.hpp"
29
29
30
30
extern "C" {
31
-
#include "FxDpcApi.tmh"
31
+
// #include "FxDpcApi.tmh"
32
32
}
33
33
34
34
//
···
39
39
_Must_inspect_result_
40
40
__drv_maxIRQL(DISPATCH_LEVEL)
41
41
NTSTATUS
42
+
STDCALL
42
43
WDFEXPORT(WdfDpcCreate)(
43
44
__in
44
45
PWDF_DRIVER_GLOBALS DriverGlobals,
···
129
130
130
131
__drv_maxIRQL(HIGH_LEVEL)
131
132
KDPC*
133
+
STDCALL
132
134
WDFEXPORT(WdfDpcWdmGetDpc)(
133
135
__in
134
136
PWDF_DRIVER_GLOBALS DriverGlobals,
···
166
168
167
169
__drv_maxIRQL(HIGH_LEVEL)
168
170
BOOLEAN
171
+
STDCALL
169
172
WDFEXPORT(WdfDpcEnqueue)(
170
173
__in
171
174
PWDF_DRIVER_GLOBALS DriverGlobals,
···
202
205
__drv_when(Wait == __true, __drv_maxIRQL(PASSIVE_LEVEL))
203
206
__drv_when(Wait == __false, __drv_maxIRQL(HIGH_LEVEL))
204
207
BOOLEAN
208
+
STDCALL
205
209
WDFEXPORT(WdfDpcCancel)(
206
210
__in
207
211
PWDF_DRIVER_GLOBALS DriverGlobals,
···
254
258
255
259
__drv_maxIRQL(HIGH_LEVEL)
256
260
WDFOBJECT
261
+
STDCALL
257
262
WDFEXPORT(WdfDpcGetParentObject)(
258
263
__in
259
264
PWDF_DRIVER_GLOBALS DriverGlobals,
+6
-6
sdk/lib/drivers/wdf/kmdf/src/core/fxsystemthread.cpp
+6
-6
sdk/lib/drivers/wdf/kmdf/src/core/fxsystemthread.cpp
···
27
27
#include "fxcorepch.hpp"
28
28
29
29
extern "C" {
30
-
#include "FxSystemThread.tmh"
30
+
// #include "FxSystemThread.tmh"
31
31
}
32
32
33
33
···
151
151
//
152
152
// The thread itself will release this reference in its exit routine
153
153
//
154
-
ADDREF(FxSystemThread::StaticThreadThunk);
154
+
ADDREF((PVOID)FxSystemThread::StaticThreadThunk);
155
155
156
156
status = PsCreateSystemThread(
157
157
&threadHandle,
···
171
171
//
172
172
// Release the reference taken above due to failure
173
173
//
174
-
RELEASE(FxSystemThread::StaticThreadThunk);
174
+
RELEASE((PVOID)FxSystemThread::StaticThreadThunk);
175
175
}
176
176
else {
177
177
status = ObReferenceObjectByHandle(
···
347
347
m_Exit = TRUE;
348
348
349
349
// Add a reference which will be released by the reaper
350
-
ADDREF(FxSystemThread::StaticReaperThunk);
350
+
ADDREF((PVOID)FxSystemThread::StaticReaperThunk);
351
351
352
352
Unlock(irql);
353
353
···
524
524
Unlock(irql);
525
525
526
526
// Release the object reference held by the thread
527
-
RELEASE(FxSystemThread::StaticThreadThunk);
527
+
RELEASE((PVOID)FxSystemThread::StaticThreadThunk);
528
528
529
529
status = PsTerminateSystemThread(STATUS_SUCCESS);
530
530
UNREFERENCED_PARAMETER(status);
···
635
635
636
636
ObDereferenceObject(m_ThreadPtr);
637
637
638
-
RELEASE(FxSystemThread::StaticReaperThunk);
638
+
RELEASE((PVOID)FxSystemThread::StaticReaperThunk);
639
639
640
640
return;
641
641
}
+3
-3
sdk/lib/drivers/wdf/kmdf/src/core/tracing.cpp
+3
-3
sdk/lib/drivers/wdf/kmdf/src/core/tracing.cpp
···
30
30
31
31
// We use DoTraceMessage
32
32
extern "C" {
33
-
#include "tracing.tmh"
33
+
// #include "tracing.tmh"
34
34
}
35
35
36
36
#include <initguid.h>
37
-
#include "fxIFR.h" // shared struct between IFR and debug ext.
38
-
#include "fxIFRKm.h" // kernel mode only IFR definitions
37
+
#include "fxifr.h" // shared struct between IFR and debug ext.
38
+
#include "fxifrkm.h" // kernel mode only IFR definitions
39
39
40
40
41
41
//=============================================================================
+2
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbuffer.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbuffer.cpp
+7
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbufferapi.cpp
+7
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxcommonbufferapi.cpp
···
21
21
22
22
--*/
23
23
24
-
#include "FxDmaPCH.hpp"
24
+
#include "fxdmapch.hpp"
25
25
26
26
extern "C" {
27
-
#include "FxCommonBufferAPI.tmh"
27
+
// #include "FxCommonBufferAPI.tmh"
28
28
}
29
29
30
30
//
···
35
35
_Must_inspect_result_
36
36
__drv_maxIRQL(PASSIVE_LEVEL)
37
37
NTSTATUS
38
+
STDCALL
38
39
WDFEXPORT(WdfCommonBufferCreate)(
39
40
__in
40
41
PWDF_DRIVER_GLOBALS DriverGlobals,
···
134
135
_Must_inspect_result_
135
136
__drv_maxIRQL(PASSIVE_LEVEL)
136
137
NTSTATUS
138
+
STDCALL
137
139
WDFEXPORT(WdfCommonBufferCreateWithConfig)(
138
140
__in
139
141
PWDF_DRIVER_GLOBALS DriverGlobals,
···
245
247
246
248
__drv_maxIRQL(DISPATCH_LEVEL)
247
249
PVOID
250
+
STDCALL
248
251
WDFEXPORT(WdfCommonBufferGetAlignedVirtualAddress)(
249
252
__in
250
253
PWDF_DRIVER_GLOBALS DriverGlobals,
···
264
267
265
268
__drv_maxIRQL(DISPATCH_LEVEL)
266
269
PHYSICAL_ADDRESS
270
+
STDCALL
267
271
WDFEXPORT(WdfCommonBufferGetAlignedLogicalAddress)(
268
272
__in
269
273
PWDF_DRIVER_GLOBALS DriverGlobals,
···
283
287
284
288
__drv_maxIRQL(DISPATCH_LEVEL)
285
289
size_t
290
+
STDCALL
286
291
WDFEXPORT(WdfCommonBufferGetLength)(
287
292
__in
288
293
PWDF_DRIVER_GLOBALS DriverGlobals,
+2
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenabler.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenabler.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenablerapi.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmaenablerapi.cpp
+1
-1
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmapch.hpp
+1
-1
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmapch.hpp
+3
-3
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransaction.cpp
+3
-3
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransaction.cpp
···
21
21
22
22
--*/
23
23
24
-
#include "FxDmaPCH.hpp"
24
+
#include "fxdmapch.hpp"
25
25
26
26
extern "C" {
27
-
#include "FxDmaTransaction.tmh"
27
+
// #include "FxDmaTransaction.tmh"
28
28
}
29
29
30
30
FxDmaTransactionBase::FxDmaTransactionBase(
···
842
842
{
843
843
BOOLEAN ret;
844
844
845
-
ret = __super::Dispose();
845
+
ret = FxDmaTransactionBase::Dispose(); // __super call
846
846
847
847
//
848
848
// Free Lookaside Buffer which held SGList
+2
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransactionapi.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransactionapi.cpp
+3
-3
sdk/lib/drivers/wdf/kmdf/src/dynamic/version/version.cpp
+3
-3
sdk/lib/drivers/wdf/kmdf/src/dynamic/version/version.cpp
···
44
44
// available in public symbols. Various WDFKD debug commands use these
45
45
// internal structures to provide information about WDF.
46
46
//-----------------------------------------------------------------------------
47
-
#include "FxIFR.h"
47
+
#include "fxifr.h"
48
48
49
49
extern "C" {
50
50
···
78
78
79
79
extern "C" {
80
80
81
-
#include "FxDynamics.h"
81
+
#include "fxdynamics.h"
82
82
83
-
#include "FxLibraryCommon.h"
83
+
#include "fxlibrarycommon.h"
84
84
85
85
#define KMDF_DEFAULT_NAME "Wdf" ## \
86
86
LITERAL(__WDF_MAJOR_VERSION_STRING) ## \
+1
-1
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiapi.cpp
+1
-1
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiapi.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiinstance.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiinstance.cpp
···
22
22
#include "fxwmipch.hpp"
23
23
24
24
extern "C" {
25
-
#include "FxWmiInstance.tmh"
25
+
// #include "FxWmiInstance.tmh"
26
26
}
27
27
28
28
FxWmiInstance::FxWmiInstance(
···
56
56
// of instances. If we don't do this, the provider will have a list which
57
57
// contains entries which have been freed.
58
58
//
59
-
return __super::Dispose();
59
+
return FxNonPagedObject::Dispose(); // __super call
60
60
}
61
61
62
62
_Must_inspect_result_
+1
-1
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp
+1
-1
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiprovider.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiprovider.cpp
···
22
22
#include "fxwmipch.hpp"
23
23
24
24
extern "C" {
25
-
#include "FxWmiProvider.tmh"
25
+
// #include "FxWmiProvider.tmh"
26
26
}
27
27
28
28
FxWmiProvider::FxWmiProvider(
···
80
80
//
81
81
m_Parent->RemoveProvider(this);
82
82
83
-
return __super::Dispose();
83
+
return FxNonPagedObject::Dispose(); // __super call
84
84
}
85
85
86
86
_Must_inspect_result_
+3
-3
sdk/lib/drivers/wdf/kmdf/src/librarycommon/fxlibrarycommon.cpp
+3
-3
sdk/lib/drivers/wdf/kmdf/src/librarycommon/fxlibrarycommon.cpp
···
19
19
20
20
#include "fx.hpp"
21
21
#include "fxldr.h"
22
-
#include "FxLibraryCommon.h"
23
-
#include "FxTelemetry.hpp"
24
-
#include "WdfVersionLog.h"
22
+
#include "fxlibrarycommon.h"
23
+
#include "fxtelemetry.hpp"
24
+
#include "wdfversionlog.h"
25
25
#include "minwindef.h"
26
26
27
27
extern "C" {
+2
-2
sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterface.cpp
+2
-2
sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterface.cpp
+3
-2
sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterfaceapi.cpp
+3
-2
sdk/lib/drivers/wdf/kmdf/src/support/fxqueryinterfaceapi.cpp
···
22
22
Revision History:
23
23
24
24
--*/
25
-
#include "FxSupportPch.hpp"
25
+
#include "fxsupportpch.hpp"
26
26
27
27
extern "C" {
28
-
#include "FxQueryInterfaceAPI.tmh"
28
+
// #include "FxQueryInterfaceAPI.tmh"
29
29
}
30
30
31
31
//
···
35
35
_Must_inspect_result_
36
36
__drv_maxIRQL(PASSIVE_LEVEL)
37
37
NTSTATUS
38
+
STDCALL
38
39
WDFEXPORT(WdfDeviceAddQueryInterface)(
39
40
__in
40
41
PWDF_DRIVER_GLOBALS DriverGlobals,
+23
-11
sdk/lib/drivers/wdf/kmdf/src/support/probeandlock.c
+23
-11
sdk/lib/drivers/wdf/kmdf/src/support/probeandlock.c
···
30
30
//
31
31
32
32
#include <ntddk.h>
33
+
#include <pseh/pseh2.h> // __REACTOS__
33
34
34
35
NTSTATUS
35
36
FxProbeAndLockForRead(
···
37
38
__in KPROCESSOR_MODE AccessMode
38
39
)
39
40
{
40
-
try {
41
+
_SEH2_TRY
42
+
{
41
43
MmProbeAndLockPages(Mdl, AccessMode, IoReadAccess);
42
-
} except(EXCEPTION_EXECUTE_HANDLER) {
43
-
return GetExceptionCode();
44
+
}
45
+
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
46
+
{
47
+
_SEH2_YIELD(return _SEH2_GetExceptionCode());
44
48
}
49
+
_SEH2_END;
45
50
46
51
return STATUS_SUCCESS;
47
52
}
···
52
57
__in KPROCESSOR_MODE AccessMode
53
58
)
54
59
{
55
-
try {
60
+
_SEH2_TRY
61
+
{
56
62
MmProbeAndLockPages(Mdl, AccessMode, IoWriteAccess);
57
-
} except(EXCEPTION_EXECUTE_HANDLER) {
58
-
return GetExceptionCode();
59
63
}
64
+
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
65
+
{
66
+
_SEH2_YIELD(return _SEH2_GetExceptionCode());
67
+
}
68
+
_SEH2_END;
69
+
60
70
return STATUS_SUCCESS;
61
71
}
62
72
···
67
77
__in LOCK_OPERATION Operation
68
78
)
69
79
{
70
-
try {
80
+
_SEH2_TRY
81
+
{
71
82
MmProbeAndLockPages(Mdl, AccessMode, Operation);
72
-
} except(EXCEPTION_EXECUTE_HANDLER) {
73
-
return GetExceptionCode();
83
+
}
84
+
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
85
+
{
86
+
_SEH2_YIELD(return _SEH2_GetExceptionCode());
74
87
}
88
+
_SEH2_END;
75
89
76
90
return STATUS_SUCCESS;
77
91
}
78
-
79
-
+72
sdk/lib/drivers/wdf/reactos_special.cpp
+72
sdk/lib/drivers/wdf/reactos_special.cpp
···
1
+
#include <stdarg.h>
2
+
#include <stddef.h>
3
+
#include <stdio.h>
4
+
#include <string.h>
5
+
#include <ntverp.h>
6
+
7
+
extern "C" {
8
+
#include <ntddk.h>
9
+
#include <ntstrsafe.h>
10
+
}
11
+
12
+
#define FX_DYNAMICS_GENERATE_TABLE 1
13
+
14
+
#include "fx.hpp"
15
+
16
+
// #include <fxldr.h>
17
+
// #include "fxbugcheck.h"
18
+
19
+
20
+
//----------------------------------------- ------------------------------------
21
+
22
+
extern "C" {
23
+
24
+
#include "fxdynamics.h"
25
+
26
+
// #include "FxLibraryCommon.h"
27
+
28
+
typedef VOID (*WDFFUNC) (VOID);
29
+
30
+
const WDFFUNC *WdfFunctions_01017 = (WDFFUNC *)(&WdfVersion.Functions);
31
+
// DECLSPEC_ALIGN(MAX_NATURAL_ALIGNMENT) UINT8 WdfDriverGlobalsVal[248] = { 0 }; // sizeof(FX_DRIVER_GLOBALS)
32
+
// PWDF_DRIVER_GLOBALS WdfDriverGlobals = &((PFX_DRIVER_GLOBALS)&WdfDriverGlobalsVal)->Public;
33
+
WDF_BIND_INFO WdfBindInfo = {0};
34
+
PWDF_DRIVER_GLOBALS WdfDriverGlobals;
35
+
36
+
#define KMDF_DEFAULT_NAME "Wdf01000"
37
+
38
+
PCHAR WdfLdrType = KMDF_DEFAULT_NAME;
39
+
40
+
WDFAPI
41
+
NTSTATUS
42
+
STDCALL
43
+
WdfApiNotImplemented()
44
+
{
45
+
DbgPrint("ReactOS KMDF: %s non-implemented API called\n");
46
+
__debugbreak();
47
+
return STATUS_UNSUCCESSFUL;
48
+
}
49
+
50
+
// called in WdfDriverCreate in fxdriverapi.cpp
51
+
VOID
52
+
RosInitWdf()
53
+
{
54
+
WdfDriverGlobals = FxAllocateDriverGlobals();
55
+
PFX_DRIVER_GLOBALS fxDriverGlobals = GetFxDriverGlobals(WdfDriverGlobals);
56
+
57
+
WdfBindInfo.Size = sizeof(WDF_BIND_INFO);
58
+
WdfBindInfo.Version.Major = 1;
59
+
WdfBindInfo.Version.Minor = 9;
60
+
WdfBindInfo.Version.Build = 7600;
61
+
WdfBindInfo.FuncCount = WdfVersion.FuncCount;
62
+
WdfBindInfo.FuncTable = (WDFFUNC *)(&WdfVersion.Functions);
63
+
fxDriverGlobals->WdfBindInfo = &WdfBindInfo;
64
+
}
65
+
66
+
void
67
+
__cxa_pure_virtual()
68
+
{
69
+
__debugbreak();
70
+
}
71
+
72
+
} // extern "C"
+2
-3
sdk/lib/drivers/wdf/umdf/fxlib/version/framework.cpp
+2
-3
sdk/lib/drivers/wdf/umdf/fxlib/version/framework.cpp
+4
-4
sdk/lib/drivers/wdf/umdf/fxlib/version/version.cpp
+4
-4
sdk/lib/drivers/wdf/umdf/fxlib/version/version.cpp
···
35
35
#include "mx.h"
36
36
}
37
37
#include "fxmin.hpp"
38
-
#include "fxldrUm.h"
39
-
#include "fxIFR.h"
38
+
#include "fxldrum.h"
39
+
#include "fxifr.h"
40
40
41
41
#include <strsafe.h>
42
42
#include <driverspecs.h>
···
45
45
46
46
extern "C" {
47
47
48
-
#include "FxDynamics.h"
48
+
#include "fxdynamics.h"
49
49
50
-
#include "..\librarycommon\FxLibraryCommon.h"
50
+
#include "..\librarycommon\fxlibrarycommon.h"
51
51
52
52
#define KMDF_DEFAULT_NAME "Wdf" ## \
53
53
LITERAL(__WDF_MAJOR_VERSION) ## \
+14
sdk/lib/drivers/wdf/usbspec.h
+14
sdk/lib/drivers/wdf/usbspec.h
···
1
+
/*
2
+
* PROJECT: Kernel Mode Device Framework
3
+
* LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4
+
* PURPOSE: Missing headers (usbspec.h)
5
+
* COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin@reactos.org)
6
+
*/
7
+
8
+
#ifndef __USBSPEC_H__
9
+
#define __USBSPEC_H__
10
+
11
+
#include <usb100.h>
12
+
#include <usb200.h>
13
+
14
+
#endif
+17
sdk/lib/drivers/wdf/wdf01000_reg.inf
+17
sdk/lib/drivers/wdf/wdf01000_reg.inf
···
1
+
; Kernel Mode Driver Frameworks (wdf01000.sys)
2
+
[AddReg]
3
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","ErrorControl",0x00010001,0x00000000
4
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","Group",0x00000000,"WdfLoadGroup"
5
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","DisplayName",0x00000000,"Kernel Mode Driver Frameworks service"
6
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","ImagePath",0x00020000,"system32\drivers\wdf01000.sys"
7
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","Start",0x00010001,0x00000003
8
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000","Type",0x00010001,0x00000001
9
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Enum","0",0x00000000,"Root\LEGACY_WDF01000\0000"
10
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Enum","Count",0x00010001,0x00000001
11
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Enum","NextInstance",0x00010001,0x00000001
12
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Parameters","BuildNumber",0x00010001,0x00001db0
13
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Parameters","MajorVersion",0x00010001,0x00000001
14
+
HKLM,"SYSTEM\CurrentControlSet\Services\Wdf01000\Parameters","MinorVersion",0x00010001,0x00000009
15
+
HKLM,"SYSTEM\CurrentControlSet\Control\Wdf\Kmdf\KmdfLibrary\Versions\1","Service",0x00000000,"Wdf01000"
16
+
HKLM,"SYSTEM\ControlSet001\Enum\Root\LEGACY_WDF01000","NextInstance",0x00010001,0x00000001
17
+
HKLM,"SYSTEM\ControlSet001\Enum\Root\LEGACY_WDF01000\0000","ActiveService",0x00000000,"Wdf01000"
+141
sdk/lib/drivers/wdf/wdfcx.h
+141
sdk/lib/drivers/wdf/wdfcx.h
···
1
+
/*
2
+
* PROJECT: Kernel Mode Device Framework
3
+
* LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4
+
* PURPOSE: Missing headers (wdfcx.h)
5
+
* COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin@reactos.org)
6
+
*/
7
+
8
+
#ifndef _WDFCX_H_
9
+
#define _WDFCX_H_
10
+
11
+
typedef BOOLEAN
12
+
(STDCALL *PFN_WDFCX_DEVICE_FILE_CREATE) (
13
+
_In_ WDFDEVICE Device,
14
+
_In_ WDFREQUEST Request,
15
+
_In_opt_ WDFFILEOBJECT FileObject);
16
+
17
+
// _WDFCX_FILEOBJECT_CONFIG_V1_17
18
+
19
+
typedef struct _WDFCX_FILEOBJECT_CONFIG {
20
+
//
21
+
// Size of this structure in bytes
22
+
//
23
+
ULONG Size;
24
+
25
+
//
26
+
// Event callback for create requests
27
+
//
28
+
PFN_WDFCX_DEVICE_FILE_CREATE EvtCxDeviceFileCreate;
29
+
30
+
//
31
+
// Event callback for close requests
32
+
//
33
+
PFN_WDF_FILE_CLOSE EvtFileClose;
34
+
35
+
//
36
+
// Event callback for cleanup requests
37
+
//
38
+
PFN_WDF_FILE_CLEANUP EvtFileCleanup;
39
+
40
+
//
41
+
// If WdfTrue, create/cleanup/close file object related requests will be
42
+
// sent down the stack.
43
+
//
44
+
// If WdfFalse, create/cleanup/close will be completed at this location in
45
+
// the device stack.
46
+
//
47
+
// If WdfDefault, behavior depends on device type
48
+
// FDO, PDO, Control: use the WdfFalse behavior
49
+
// Filter: use the WdfTrue behavior
50
+
//
51
+
WDF_TRI_STATE AutoForwardCleanupClose;
52
+
53
+
//
54
+
// Specify whether framework should create WDFFILEOBJECT and also
55
+
// whether it can FsContexts fields in the WDM fileobject to store
56
+
// WDFFILEOBJECT so that it can avoid table look up and improve perf.
57
+
//
58
+
WDF_FILEOBJECT_CLASS FileObjectClass;
59
+
60
+
} WDFCX_FILEOBJECT_CONFIG, *PWDFCX_FILEOBJECT_CONFIG;
61
+
62
+
typedef NTSTATUS
63
+
(STDCALL *PFN_WDFCXDEVICE_WDM_IRP_PREPROCESS)(
64
+
_In_ WDFDEVICE Device,
65
+
_Inout_ PIRP Irp,
66
+
_In_ PVOID DispatchContext);
67
+
68
+
typedef PWDFCXDEVICE_INIT
69
+
(STDCALL *PFN_WDFCXDEVICEINITALLOCATE)(
70
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
71
+
_In_ PWDFDEVICE_INIT DeviceInit);
72
+
73
+
typedef NTSTATUS
74
+
(STDCALL *PFN_WDFCXDEVICEINITASSIGNWDMIRPPREPROCESSCALLBACK) (
75
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
76
+
_In_ PWDFCXDEVICE_INIT CxDeviceInit,
77
+
_In_ PFN_WDFCXDEVICE_WDM_IRP_PREPROCESS EvtCxDeviceWdmIrpPreprocess,
78
+
_In_ UCHAR MajorFunction,
79
+
_When_(NumMinorFunctions > 0, _In_reads_bytes_(NumMinorFunctions))
80
+
_When_(NumMinorFunctions == 0, _In_opt_)
81
+
PUCHAR MinorFunctions,
82
+
_In_ ULONG NumMinorFunctions);
83
+
84
+
typedef VOID
85
+
(STDCALL *PFN_WDFCXDEVICEINITSETIOINCALLERCONTEXTCALLBACK)(
86
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
87
+
_In_ PWDFCXDEVICE_INIT CxDeviceInit,
88
+
_In_ PFN_WDF_IO_IN_CALLER_CONTEXT EvtIoInCallerContext);
89
+
90
+
typedef VOID
91
+
(STDCALL *PFN_WDFCXDEVICEINITSETREQUESTATTRIBUTES)(
92
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
93
+
_In_ PWDFCXDEVICE_INIT CxDeviceInit,
94
+
_In_ PWDF_OBJECT_ATTRIBUTES RequestAttributes);
95
+
96
+
typedef VOID
97
+
(STDCALL *PFN_WDFCXDEVICEINITSETFILEOBJECTCONFIG)(
98
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
99
+
_In_ PWDFCXDEVICE_INIT CxDeviceInit,
100
+
_In_ PWDFCX_FILEOBJECT_CONFIG CxFileObjectConfig,
101
+
_In_opt_ PWDF_OBJECT_ATTRIBUTES FileObjectAttributes);
102
+
103
+
typedef VOID
104
+
(STDCALL *PFN_WDFCXVERIFIERKEBUGCHECK)(
105
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
106
+
_In_opt_ WDFOBJECT Object,
107
+
_In_ ULONG BugCheckCode,
108
+
_In_ ULONG_PTR BugCheckParameter1,
109
+
_In_ ULONG_PTR BugCheckParameter2,
110
+
_In_ ULONG_PTR BugCheckParameter3,
111
+
_In_ ULONG_PTR BugCheckParameter4);
112
+
113
+
typedef WDFIOTARGET
114
+
(STDCALL *PFN_WDFDEVICEGETSELFIOTARGET)(
115
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
116
+
_In_ WDFDEVICE Device);
117
+
118
+
typedef VOID
119
+
(STDCALL *PFN_WDFDEVICEINITALLOWSELFIOTARGET)(
120
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
121
+
_In_ PWDFDEVICE_INIT DeviceInit);
122
+
123
+
typedef NTSTATUS
124
+
(STDCALL *PFN_WDFIOTARGETSELFASSIGNDEFAULTIOQUEUE)(
125
+
_In_ PWDF_DRIVER_GLOBALS DriverGlobals,
126
+
_In_ WDFIOTARGET IoTarget,
127
+
_In_ WDFQUEUE Queue);
128
+
129
+
// some other random stuff
130
+
131
+
typedef PVOID PFN_WDF_CLASS_EXTENSIONIN_BIND;
132
+
typedef PVOID PFN_WDF_CLASS_EXTENSIONIN_UNBIND;
133
+
typedef PVOID PFN_WDF_CLASS_EXPORT;
134
+
typedef PVOID PFN_WDF_CLASS_LIBRARY_INITIALIZE;
135
+
typedef PVOID PFN_WDF_CLASS_LIBRARY_DEINITIALIZE;
136
+
typedef PVOID PFN_WDF_CLASS_LIBRARY_BIND_CLIENT;
137
+
typedef PVOID PFN_WDF_CLASS_LIBRARY_UNBIND_CLIENT;
138
+
typedef PVOID PFN_WDF_CLIENT_BIND_CLASS;
139
+
typedef PVOID PFN_WDF_CLIENT_UNBIND_CLASS;
140
+
141
+
#endif // _WDFCX_H_
+38
sdk/lib/drivers/wdf/wdfldr.h
+38
sdk/lib/drivers/wdf/wdfldr.h
···
1
+
/*
2
+
* PROJECT: Kernel Mode Device Framework
3
+
* LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4
+
* PURPOSE: Missing headers (wdfldr.h)
5
+
* COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin@reactos.org)
6
+
*/
7
+
8
+
// likely to be removed when the proper wdfldr.sys is ready
9
+
10
+
#ifndef _WDFLDR_H_
11
+
#define _WDFLDR_H_
12
+
13
+
#ifdef __cplusplus
14
+
extern "C" {
15
+
#endif
16
+
17
+
typedef struct _LIBRARY_MODULE* PLIBRARY_MODULE;
18
+
typedef struct _WDF_LIBRARY_INFO* PWDF_LIBRARY_INFO;
19
+
20
+
typedef ULONG WDF_MAJOR_VERSION;
21
+
typedef ULONG WDF_MINOR_VERSION;
22
+
typedef ULONG WDF_BUILD_NUMBER;
23
+
typedef PVOID WDF_COMPONENT_GLOBALS, *PWDF_COMPONENT_GLOBALS;
24
+
25
+
typedef struct _WDF_INTERFACE_HEADER {
26
+
const GUID *InterfaceType;
27
+
ULONG InterfaceSize;
28
+
} WDF_INTERFACE_HEADER, *PWDF_INTERFACE_HEADER;
29
+
30
+
typedef struct _WDF_BIND_INFO *PWDF_BIND_INFO;
31
+
32
+
typedef NTSTATUS (STDCALL *PWDF_LDR_DIAGNOSTICS_VALUE_BY_NAME_AS_ULONG)(PUNICODE_STRING, PULONG);
33
+
34
+
#ifdef __cplusplus
35
+
} // extern "C"
36
+
#endif
37
+
38
+
#endif // _WDFLDR_H_