Public Member Functions |
Static Public Member Functions |
Public Attributes |
Static Public Attributes |
Protected Member Functions |
Static Protected Member Functions |
Static Protected Attributes |
Private Member Functions |
Static Private Member Functions |
Private Attributes |
Static Private Attributes |
List of all members
FxPkgFdo Class Reference
#include <fxpkgfdo.hpp>
Inheritance diagram for FxPkgFdo:
Collaboration diagram for FxPkgFdo:
Static Public Attributes | |
| static MdCompletionRoutineType | RaiseDevicePowerCompletion |
Static Protected Attributes | |
| static MdCompletionRoutineType | _SystemPowerS0Completion |
| static MdCompletionRoutineType | _SystemPowerSxCompletion |
 Static Protected Attributes inherited from FxPkgPnp | |
| static MdCancelRoutineType | _PowerWaitWakeCancelRoutine |
| static MdRequestPowerCompleteType | _PowerPolDeviceWaitWakeComplete |
| static MdRequestPowerCompleteType | _PowerPolDevicePowerDownComplete |
| static MdRequestPowerCompleteType | _PowerPolDevicePowerUpComplete |
| static MdCompletionRoutineType | _PowerPolicyWaitWakeCompletionRoutine |
| static MdCompletionRoutineType | _PowerPolicyUsbSelectiveSuspendCompletionRoutine |
| static const GUID | GUID_POWER_THREAD_INTERFACE |
Static Private Attributes | |
| static const PFN_PNP_POWER_CALLBACK | m_FdoPnpFunctionTable [IRP_MN_SURPRISE_REMOVAL+1] |
| static const PFN_PNP_POWER_CALLBACK | m_FdoPowerFunctionTable [IRP_MN_QUERY_POWER+1] |
Detailed Description
Definition at line 34 of file fxpkgfdo.hpp.
Constructor & Destructor Documentation
◆ FxPkgFdo()
|
private |
Definition at line 114 of file fxpkgfdo.cpp.
117 :
119/*++
120
121Routine Description:
122
123 This is the constructor for the FxPkgFdo. Don't do any initialization
124 that might fail here.
125
126Arguments:
127
128 none
129
130Returns:
131
132 none
133
134--*/
135
136{
139
142
143 m_BusEnumRetries = 0;
144
145 //
146 // Since we will always have a valid PDO when we are the FDO, we can do
147 // any device interface related activity at any time
148 //
150
152
154
157}
REENUMERATE_SELF_INTERFACE_STANDARD m_SurpriseRemoveAndReenumerateSelfInterface
Definition: fxpkgfdo.hpp:57
Definition: fxpkgpnp.hpp:488
BOOLEAN m_DeviceInterfacesCanBeEnabled
Definition: fxpkgpnp.hpp:4128
◆ ~FxPkgFdo()
|
protected |
Definition at line 159 of file fxpkgfdo.cpp.
178{
181 }
184 }
187 }
190 }
191}
Member Function Documentation
◆ _Create()
|
static |
Definition at line 195 of file fxpkgfdo.cpp.
200{
202 FxPkgFdo * fxPkgFdo;
203 FxEventQueue *eventQueue;
204
206
212 }
213
214 //
215 // Initialize the event queues in the PnP, power and power policy state
216 // machines
217 //
222 }
223
228 }
229
234 }
235
236 *PkgFdo = fxPkgFdo;
237
238exit:
240 fxPkgFdo->DeleteFromFailedCreate();
241 }
242
244}
Definition: fxpkgfdo.hpp:35
FxPowerPolicyMachine m_PowerPolicyMachine
Definition: fxpkgpnp.hpp:4153
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
Definition: fxeventqueue.hpp:51
_Must_inspect_result_ NTSTATUS Initialize(__in PFX_DRIVER_GLOBALS DriverGlobals)
Definition: eventqueue.cpp:55
Referenced by FxDevice::FdoInitialize().
◆ _DispatchQueryPower()
|
staticprivate |
Definition at line 123 of file fdopower.cpp.
146{
149 }
150 else {
152 }
153}
◆ _DispatchSetPower()
|
staticprivate |
Definition at line 90 of file fdopower.cpp.
◆ _PnpFilteredStartDeviceCompletionRoutine()
|
staticprotected |
Definition at line 1438 of file fxpkgfdo.cpp.
1443{
1444 FxFilteredStartContext *pContext;
1446
1448
1449 //
1450 // Save off the package so we can use it after we free the context
1451 //
1453
1454 delete pContext;
1455
1457}
static _Must_inspect_result_ NTSTATUS STDCALL _PnpStartDeviceCompletionRoutine(__in MdDeviceObject DeviceObject, __inout MdIrp Irp, __inout PVOID Context)
Definition: fxpkgfdo.cpp:1462
Definition: compobj.c:4795
Definition: fxpkgfdo.cpp:44
Referenced by PnpSendStartDeviceDownTheStackOverload().
◆ _PnpFilterResourceRequirements()
|
staticprivate |
Definition at line 748 of file fxpkgfdo.cpp.
◆ _PnpPassDown()
|
staticprivate |
Definition at line 307 of file fxpkgfdo.cpp.
324{
328
331
332 Irp->CopyCurrentIrpStackLocationToNext();
335
337 pIrp
338 );
339
341}
MdDeviceObject __inline GetAttachedDevice(VOID)
Definition: fxdevice.hpp:210
Definition: fxdevice.hpp:487
static __inline VOID MxReleaseRemoveLock(__in MdRemoveLock RemoveLock, __in PVOID Tag)
Definition: mxgeneralkm.h:278
Definition: devices.h:37
Referenced by _PnpQueryInterface(), FireAndForgetIrp(), and PnpQueryDeviceRelations().
◆ _PnpQueryCapabilities()
|
staticprivate |
Definition at line 551 of file fxpkgfdo.cpp.
◆ _PnpQueryCapabilitiesCompletionRoutine()
|
staticprivate |
Definition at line 227 of file fxpkgfdokm.cpp.
232{
236
238
240}
◆ _PnpQueryDeviceRelations()
|
staticprivate |
Definition at line 372 of file fxpkgfdo.cpp.
◆ _PnpQueryInterface()
|
staticprivate |
Definition at line 490 of file fxpkgfdo.cpp.
511{
512 FxPkgFdo* pThis;
514 BOOLEAN completeIrp;
515
517
519 "Entering QueryInterface handler");
520
522
524 "Exiting QueryInterface handler, %!STATUS!",
525 status);
526 //
527 // If we understand the irp, we'll complete it. Otherwise we
528 // pass it down.
529 //
532 }
533 else {
536 }
537
538 //
539 // Remlock is released in _PnpPassDown and CompletePnpRequest. If this
540 // irp is racing with remove on another thread, it's possible for the device
541 // to get deleted right after the lock is released and before anything
542 // after this point is executed. So make sure to not touch any memory in
543 // the return path.
544 //
545
547}
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
static _Must_inspect_result_ NTSTATUS _PnpPassDown(__in FxPkgPnp *This, __inout FxIrp *Irp)
Definition: fxpkgfdo.cpp:307
NTSTATUS CompletePnpRequest(__inout FxIrp *Irp, __in NTSTATUS Status)
Definition: fxpkgpnp.cpp:5752
_Must_inspect_result_ NTSTATUS HandleQueryInterface(__inout FxIrp *Irp, __out PBOOLEAN CompleteRequest)
Definition: fxpkgpnp.cpp:1493
◆ _PnpQueryPnpDeviceState()
|
staticprivate |
Definition at line 305 of file fxpkgfdokm.cpp.
326{
327 FxPkgFdo* pThis;
329
331
333
335 //
336 // Morph into a successful code so that we process the request
337 //
340 }
341
344 }
345 else {
346 DoTraceLevelMessage(
348 "Lower stack returned error for query pnp device state, %!STATUS!",
349 status);
350 }
351
352 //
353 // Since we already sent the request down the stack, we must complete it
354 // now.
355 //
357}
VOID HandleQueryPnpDeviceStateCompletion(__inout FxIrp *Irp)
Definition: fxpkgfdo.cpp:763
virtual _Must_inspect_result_ NTSTATUS SendIrpSynchronously(__inout FxIrp *Irp)
Definition: fxpkgfdo.cpp:248
◆ _PnpQueryPnpDeviceStateCompletionRoutine()
|
staticprivate |
Definition at line 288 of file fxpkgfdokm.cpp.
293{
297
299
301}
◆ _PnpStartDeviceCompletionRoutine()
|
staticprotected |
Definition at line 1462 of file fxpkgfdo.cpp.
1467{
1468 FxPkgFdo* pThis;
1470
1472
1474
1477
1478 //
1479 // Only raise irql if we are the power policy owner. Only the p.p.o.
1480 // does this so that we only have one driver in the device stack moving
1481 // to another thread.
1482 //
1485
1486 //
1487 // By raising to dispatch level we are forcing the pnp state machine
1488 // to move to another thread. On NT 6.0 PnP supports asynchronous
1489 // starts, so this will other starts to proceed while WDF processes
1490 // this device starting.
1491 //
1494 Mx::MxLowerIrql(irql);
1495 }
1496 else {
1498 }
1499 }
1500 else {
1501 //
1502 // Just complete the request, the current pnp state can handle the remove
1503 // which will be sent b/c of the failed start.
1504 //
1505 DoTraceLevelMessage(
1508
1509 //
1510 // Process the event *before* completing the irp so that this even is in
1511 // the queue before the device remove event which will be be processed
1512 // right after the start irp has been completed.
1513 //
1515
1517 }
1518
1520}
Definition: fxirp.hpp:28
VOID PnpProcessEvent(__in FxPnpEvent Event, __in BOOLEAN ProcessEventOnDifferentThread=FALSE)
Definition: pnpstatemachine.cpp:823
VOID SetPendingPnpIrp(__inout FxIrp *Irp, __in BOOLEAN MarkIrpPending=TRUE)
Definition: fxpkgpnp.cpp:4883
Referenced by _PnpFilteredStartDeviceCompletionRoutine(), and PnpSendStartDeviceDownTheStackOverload().
◆ _PnpSurpriseRemoval()
|
staticprivate |
Definition at line 345 of file fxpkgfdo.cpp.
◆ _PowerPassDown()
|
staticprivate |
Definition at line 43 of file fdopower.cpp.
66{
67 FxPkgFdo* pThis;
70
73
74 //
75 // FDOs don't handle this IRP, so simply pass it down.
76 //
77 Irp->StartNextPowerIrp();
78 Irp->CopyCurrentIrpStackLocationToNext();
79
81
83 pIrp);
84
86}
Referenced by DispatchDeviceQueryPower(), DispatchSystemQueryPower(), DispatchSystemSetPower(), FireAndForgetIrp(), and PowerReleasePendingDeviceIrp().
◆ AskParentToRemoveAndReenumerate()
|
privatevirtual |
◆ CreateDefaultDeviceList()
| _Must_inspect_result_ NTSTATUS FxPkgFdo::CreateDefaultDeviceList | ( | __in PWDF_CHILD_LIST_CONFIG | ListConfig, |
| __in PWDF_OBJECT_ATTRIBUTES | ListAttributes | ||
| ) |
Definition at line 816 of file fxpkgfdo.cpp.
836{
838 WDFCHILDLIST hList;
841
843
845
846 //
847 // This should not fail, we already validated the total size when we
848 // validated the config (we just had no place to store the total size, so
849 // we recompute it again).
850 //
852 pFxDriverGlobals,
853 ListConfig,
854 &totalDescriptionSize
855 );
858 }
859
861 pFxDriverGlobals,
862 ListAttributes,
863 totalDescriptionSize,
864 m_Device,
865 ListConfig);
868 }
869
872 m_Device);
873
876 "Could not convert object to handle");
880 }
881
882 //
883 // This will be released in the destructor
884 //
886
888}
static _Must_inspect_result_ NTSTATUS _CreateAndInit(__out FxChildList **ChildList, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES ListAttributes, __in size_t TotalDescriptionSize, __in CfxDevice *Device, __in PWDF_CHILD_LIST_CONFIG ListConfig, __in BOOLEAN Static=FALSE)
Definition: fxchildlist.cpp:367
static _Must_inspect_result_ NTSTATUS _ComputeTotalDescriptionSize(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_CHILD_LIST_CONFIG Config, __in size_t *TotalDescriptionSize)
Definition: fxchildlist.cpp:3194
_Must_inspect_result_ NTSTATUS Commit(__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
Definition: fxobject.cpp:904
Definition: nsiface.idl:2307
Definition: fxglobals.h:165
Referenced by FxDevice::FdoInitialize().
◆ DeleteSymbolicLinkOverload()
Definition at line 1280 of file fxpkgfdo.cpp.
1296{
1297 UNREFERENCED_PARAMETER(GracefulRemove);
1298
1299 //
1300 // We always remove the symbolic link for an FDO since there is no presence
1301 // state to check.
1302 //
1304}
◆ DispatchDeviceQueryPower()
|
private |
Definition at line 446 of file fdopower.cpp.
449{
450 //
451 // Either the framework is the power policy owner and we wouldn't be sending
452 // a device query power or we are a subordinate will do what the power
453 // policy owner wants 100% of the time.
454 //
456
457 //
458 // This will release the remove lock
459 //
461}
static _Must_inspect_result_ NTSTATUS _PowerPassDown(__inout FxPkgPnp *This, __in FxIrp *Irp)
Definition: fdopower.cpp:43
◆ DispatchDeviceSetPower()
|
private |
Definition at line 299 of file fdopower.cpp.
303{
305
309 //
310 // A power irp arrived, but we did not request it. log and bugcheck
311 //
312 DoTraceLevelMessage(
314 "Received set device power irp 0x%p on WDFDEVICE 0x%p !devobj 0x%p, "
315 "but the irp was not requested by the device (the power policy owner)",
318
323
324 /* NOTREACHED */
325 }
326
327 //
328 // We are no longer requesting a power irp because we received the one
329 // we requested.
330 //
333 } else {
335 }
336 }
337
338 //
339 // Determine if we are raising or lowering the device power state.
340 //
343 }
344 else {
346 }
347
349}
MdDeviceObject __inline GetDeviceObject(VOID)
Definition: fxdevice.hpp:174
_Must_inspect_result_ NTSTATUS RaiseDevicePower(__in FxIrp *Irp)
Definition: fdopower.cpp:353
_Must_inspect_result_ NTSTATUS LowerDevicePower(__in FxIrp *Irp)
Definition: fdopower.cpp:401
FxPowerPolicyOwnerSettings * m_Owner
Definition: fxpowerpolicystatemachine.hpp:777
BOOLEAN m_RequestedPowerUpIrp
Definition: fxpowerpolicystatemachine.hpp:660
BOOLEAN m_RequestedPowerDownIrp
Definition: fxpowerpolicystatemachine.hpp:661
◆ DispatchSystemQueryPower()
|
private |
Definition at line 417 of file fdopower.cpp.
420{
423
425 Irp->GetParameterPowerStateSystemState()
426 );
427
429
432 }
433 }
434
435 //
436 // Passing down the irp because one of the following
437 // a) We don't care b/c we don't control the power policy
438 // b) we are not enabled for arming for wake from Sx
439 // c) we can wake from the queried S state
440 //
442}
_Must_inspect_result_ NTSTATUS PowerPolicyHandleSystemQueryPower(__in SYSTEM_POWER_STATE QueryState)
Definition: fxpkgpnp.cpp:3582
BOOLEAN PowerPolicyIsWakeEnabled(VOID)
Definition: fxpkgpnp.cpp:5769
NTSTATUS CompletePowerRequest(__inout FxIrp *Irp, __in NTSTATUS Status)
Definition: fxpkgpnp.cpp:5404
◆ DispatchSystemSetPower()
|
private |
Definition at line 236 of file fdopower.cpp.
239{
242
245 Irp->GetParameterPowerState());
246
248 //
249 // If we are going to S0, we just notify the power policy state machine
250 // and then let the request go (per the fast resume spec). Otherwise,
251 // send the request down and on the way up, send the Dx request.
252 //
254 //
255 // Post the event into the state machine when the irp is going up
256 // the stack. See the comment in _SystemPowerS0Completion for more
257 // detail as to why.
258 //
259 Irp->CopyCurrentIrpStackLocationToNext();
262 this);
263
265 }
266 else {
267 //
268 // Stash away the irp for the power policy state machine. We will
269 // post the event to the power policy state machine when the S irp
270 // completes back to this driver.
271 //
273
274 Irp->CopyCurrentIrpStackLocationToNext();
277 this);
278
280
282 }
283 }
284 else {
285 //
286 // We don't do anything with S irps if we are not the power policy
287 // owner.
288 //
289 // This will release the remove lock as well.
290 //
292 }
293
295}
static MdCompletionRoutineType _SystemPowerS0Completion
Definition: fxpkgfdo.hpp:461
static MdCompletionRoutineType _SystemPowerSxCompletion
Definition: fxpkgfdo.hpp:465
VOID SetPendingSystemPowerIrp(__inout FxIrp *Irp)
Definition: fxpkgpnp.hpp:3082
Definition: mxdeviceobject.h:21
POWER_STATE SetPowerState(__in POWER_STATE_TYPE Type, __in POWER_STATE State)
Definition: mxdeviceobjectkm.h:88
◆ FireAndForgetIrp()
|
privatevirtual |
Definition at line 276 of file fxpkgfdo.cpp.
296{
299 }
300 else {
302 }
303}
#define IRP_MJ_POWER
◆ GetDispatchPnp()
|
inlineprivatevirtual |
Implements FxPkgPnp.
Definition at line 428 of file fxpkgfdo.hpp.
431 {
433 }
static const PFN_PNP_POWER_CALLBACK m_FdoPnpFunctionTable[IRP_MN_SURPRISE_REMOVAL+1]
Definition: fxpkgfdo.hpp:74
◆ GetDispatchPower()
|
inlineprivatevirtual |
Implements FxPkgPnp.
Definition at line 437 of file fxpkgfdo.hpp.
440 {
442 }
static const PFN_PNP_POWER_CALLBACK m_FdoPowerFunctionTable[IRP_MN_QUERY_POWER+1]
Definition: fxpkgfdo.hpp:79
◆ HandleQueryCapabilities()
Definition at line 572 of file fxpkgfdo.cpp.
575{
576 PDEVICE_CAPABILITIES pCaps;
577 LONG pnpCaps;
578
580 "Entering QueryCapabilities handler");
581
582 pCaps = Irp->GetParameterDeviceCapabilities();
583
584 pnpCaps = GetPnpCapsInternal();
585
586 //
587 // Add Capabilities. These need to be done as the IRP goes down, since
588 // lower drivers need to see them.
589 //
591 SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, LockSupported);
592 SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, EjectSupported);
594 SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, DockDevice);
595 SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, SurpriseRemovalOK);
596 SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, NoDisplayInUI);
597 //
598 // If the driver has declared a wake capable interrupt,
599 // we need to set this bit in the capabilities so that
600 // ACPI will relinquish control of wake responsiblity
601 //
603 pCaps->WakeFromInterrupt = TRUE;
604 }
605 }
606
608 "Exiting QueryCapabilities handler");
609 return;
610}
Referenced by PnpQueryCapabilities().
◆ HandleQueryCapabilitiesCompletion()
Definition at line 613 of file fxpkgfdo.cpp.
616{
617 PDEVICE_CAPABILITIES pCaps;
618 LONG pnpCaps;
620
622 "Entering QueryCapabilities completion handler");
623
624 pCaps = Irp->GetParameterDeviceCapabilities();
625
626 pnpCaps = GetPnpCapsInternal();
627
628 //
629 // Confirm this is a valid DeviceCapabilities structure.
630 //
632 ASSERT(pCaps->Version >= 1);
633
635 (pCaps->Version == 1)) {
636 ULONG states;
637
638 //
639 // Remove Capabilities
640 //
641
642 //
643 // Re-add SOME capibilties that the bus driver may have accidentally
644 // stomped.
645
646
647
648
649
650 SET_PNP_CAP_IF_FALSE(pnpCaps, pCaps, LockSupported);
651 SET_PNP_CAP_IF_FALSE(pnpCaps, pCaps, EjectSupported);
652 SET_PNP_CAP_IF_FALSE(pnpCaps, pCaps, DockDevice);
653
655 SET_PNP_CAP(pnpCaps, pCaps, SurpriseRemovalOK);
656
657 //
658 // The DeviceState array contains a table of D states that correspond
659 // to a given S state. If the driver writer initialized entries of the
660 // array, and if the new value is a deeper sleep state than the
661 // original, we will use the new driver supplied value.
662 //
664
667
668 //
669 // PowerDeviceMaximum indicates to use the default value
670 //
671 // We are only allowed to deepen the D states, not lighten them,
672 // hence the > compare.
673 //
675
678 }
679 }
680
681 //
682 // If the driver supplied SystemWake value is lighter than the current
683 // value, then use the driver supplied value.
684 //
685 // PowerSystemMaximum indicates to use the default value
686 //
687 // We are only allowed to lighten the S state, not deepen it, hence
688 // the < compare.
689 //
693 }
694
695 //
696 // Same for DeviceWake
697 //
701 }
702
703 //
704 // Set the Device wake up latencies. A value of -1 indicates to
705 // use the default values provided by the lower stack.
706 //
710 }
711
715 }
716
720 }
721
722 //
723 // Set the Address and the UI number values. A value of -1 indicates
724 // to use the default values provided by the lower stack.
725 //
727 pCaps->Address = m_PnpCapsAddress;
728 }
729
731 pCaps->UINumber= m_PnpCapsUINumber;
732 }
733 }
734
735 //
736 // CompletePnpRequest is called after return from this function
737 // so it is safe to log here
738 //
739
741 "Exiting QueryCapabilities completion handler");
742
743 return;
744}
static DEVICE_POWER_STATE _GetPowerCapState(__in ULONG Index, __in ULONG State)
Definition: fxpkgpnp.cpp:5657
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
enum _DEVICE_POWER_STATE DEVICE_POWER_STATE
enum _SYSTEM_POWER_STATE SYSTEM_POWER_STATE
Referenced by PnpQueryCapabilities().
◆ HandleQueryPnpDeviceStateCompletion()
Definition at line 763 of file fxpkgfdo.cpp.
766{
767 PNP_DEVICE_STATE pnpDeviceState;
768
769 DoTraceLevelMessage(
771 "Entering QueryPnpDeviceState completion handler");
772
773 pnpDeviceState = HandleQueryPnpDeviceState(
775 );
776
778
779 DoTraceLevelMessage(
781 "WDFDEVICE 0x%p !devobj 0x%p returning PNP_DEVICE_STATE 0x%d IRP 0x%p",
784 pnpDeviceState,
785 Irp->GetIrp());
786
787 DoTraceLevelMessage(
789 "Exiting QueryPnpDeviceState completion handler");
790
791 return;
792}
PNP_DEVICE_STATE HandleQueryPnpDeviceState(__in PNP_DEVICE_STATE PnpDeviceState)
Definition: fxpkgpnp.cpp:662
Referenced by _PnpQueryPnpDeviceState().
◆ Initialize()
|
virtual |
Reimplemented from FxPkgPnp.
Definition at line 361 of file fxpkgfdokm.cpp.
392{
396 WDFCHILDLIST hList;
398
400
404 }
405
409 }
410
411 #pragma prefast(suppress: __WARNING_PASSING_FUNCTION_UNEXPECTED_NULL, "Static child lists do not use the EvtChildListCreateDevice callback")
414 NULL);
415
417 &config,
418 &totalDescriptionSize);
421 }
422
424 pGlobals,
426 totalDescriptionSize,
427 m_Device,
428 &config,
429 TRUE);
432 }
433
436 m_Device);
437
441
443 }
444
445 //
446 // This will be released in the destructor
447 //
449
451}
_Must_inspect_result_ NTSTATUS AllocateEnumInfo(VOID)
Definition: fxpkgpnp.cpp:4920
virtual _Must_inspect_result_ NTSTATUS Initialize(__in PWDFDEVICE_INIT DeviceInit)
Definition: fxpkgpnp.cpp:349
struct config_s config
Definition: fxpkgfdo.hpp:28
Definition: wdfchildlist.h:320
Definition: deflate.c:114
FORCEINLINE VOID WDF_CHILD_LIST_CONFIG_INIT(_Out_ PWDF_CHILD_LIST_CONFIG Config, _In_ ULONG IdentificationDescriptionSize, _In_ PFN_WDF_CHILD_LIST_CREATE_DEVICE EvtChildListCreateDevice)
Definition: wdfchildlist.h:415
Referenced by FxDevice::FdoInitialize().
◆ IsFilter()
Definition at line 130 of file fxpkgfdo.hpp.
◆ LowerDevicePower()
|
private |
Definition at line 401 of file fdopower.cpp.
404{
406
407 //
408 // Kick off the power state machine.
409 //
411
413}
VOID SetPendingDevicePowerIrp(__inout FxIrp *Irp)
Definition: fxpkgpnp.hpp:3050
VOID PowerProcessEvent(__in FxPowerEvent Event, __in BOOLEAN ProcessEventOnDifferentThread=FALSE)
Definition: powerstatemachine.cpp:1156
Referenced by DispatchDeviceSetPower().
◆ PnpEventCheckForDevicePresenceOverload()
|
privatevirtual |
Implements FxPkgPnp.
Definition at line 1133 of file fxpkgfdo.cpp.
1156{
1158
1159 //
1160 // Do something safe. Act like the device is not
1161 // present.
1162 //
1164}
◆ PnpEventEjectHardwareOverload()
|
privatevirtual |
Implements FxPkgPnp.
Definition at line 1099 of file fxpkgfdo.cpp.
1122{
1124
1125 //
1126 // Do something safe. Act like the device got
1127 // ejected.
1128 //
1130}
@ WdfDevStatePnpEjectedWaitingForRemove
Definition: wdfdevice.h:68
◆ PnpEventFdoRemovedOverload()
|
privatevirtual |
Implements FxPkgPnp.
Definition at line 1224 of file fxpkgfdo.cpp.
1239{
1240 //
1241 // Do that which all device stacks need to do upon removal.
1242 //
1243 PnpEventRemovedCommonCode();
1244
1246}
VOID PnpEventRemovedCommonCode(VOID)
Definition: pnpstatemachine.cpp:1989
◆ PnpEventPdoRemovedOverload()
|
privatevirtual |
◆ PnpFilterResourceRequirements()
|
private |
Definition at line 43 of file fxpkgfdokm.cpp.
65{
66 PIO_RESOURCE_REQUIREMENTS_LIST pWdmRequirementsList;
67 PIO_RESOURCE_REQUIREMENTS_LIST pNewWdmList;
70 WDFIORESREQLIST reqlist;
71
73 "Entering FilterResourceRequirements handler");
74
76
78
80
82 pWdmRequirementsList,
84
87
88 // Commit should never fail because we own all object state
91
94
97
99 //
100 // List could be missing previously
101 //
103 //
104 // Propagate BusNumber to our new list.
105 //
107
108 MxMemory::MxFreePool(pWdmRequirementsList);
109 }
110
112 }
113 else {
115 }
116 }
117
118 //
119 // No matter what, free the resource requirements list object. If
120 // we need another one when adding resources, another one will be
121 // allocated.
122 //
125 }
126 }
127 else {
128 //
129 // No filtering on the way down, set status to STATUS_SUCCESS so we
130 // send the irp down the stack.
131 //
133 }
134
137 }
138
139 //
140 // If we do not handle the IRP on the way down and the PDO does not handle
141 // the IRP, we can have a status of STATUS_NOT_SUPPORTED. We still want to
142 // process the irp in this state.
143 //
145 NTSTATUS filterStatus;
146
147 //
148 // Give the Framework objects a pass at the list.
149 //
150 filterStatus = FxPkgPnp::FilterResourceRequirements(
152 );
153
155 status = filterStatus;
156 }
158 //
159 // Now give the driver a shot at it.
160 //
161 pWdmRequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST)
162 Irp->GetInformation();
163
166
170
171 //
172 // Since we absolutely control the lifetime of pIoResReqList, this
173 // should never fail
174 //
176
179
180 //
181 // It is possible the child driver modified the resource list,
182 // and if so we need to update the requirements list.
183 //
186
188 //
189 // List could be missing previously
190 //
192 //
193 // Propagate BusNumber to our new list.
194 //
196
197 ExFreePool(pWdmRequirementsList);
198 }
199
201 }
202 else {
204 }
205 }
206
209 }
210 else {
212 }
213 }
214 }
215
217
219 "Exiting FilterResourceRequirements handler, %!STATUS!",
220 status);
221
223}
struct _IO_RESOURCE_REQUIREMENTS_LIST * PIO_RESOURCE_REQUIREMENTS_LIST
Definition: fxresource.hpp:626
_Must_inspect_result_ PIO_RESOURCE_REQUIREMENTS_LIST CreateWdmList(VOID)
Definition: fxresourcecollection.cpp:564
static _Must_inspect_result_ FxIoResReqList * _CreateFromWdmList(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PIO_RESOURCE_REQUIREMENTS_LIST WdmRequirementsList, __in UCHAR AccessFlags)
Definition: fxresourcecollection.cpp:477
FxPnpDeviceFilterResourceRequirements m_DeviceFilterRemoveResourceRequirements
Definition: fxpkgfdo.hpp:65
FxPnpDeviceFilterResourceRequirements m_DeviceFilterAddResourceRequirements
Definition: fxpkgfdo.hpp:63
NTSTATUS FilterResourceRequirements(__in IO_RESOURCE_REQUIREMENTS_LIST **IoList)
Definition: fxpkgpnpkm.cpp:16
_Must_inspect_result_ NTSTATUS Invoke(__in WDFDEVICE Device, __in WDFIORESREQLIST Collection)
Definition: fxpnpcallbacks.hpp:41
PFN_WDF_DEVICE_FILTER_RESOURCE_REQUIREMENTS m_Method
Definition: fxpnpcallbacks.hpp:31
Definition: edit.c:128
◆ PnpGetPostRemoveState()
|
privatevirtual |
◆ PnpQueryCapabilities()
|
private |
Definition at line 244 of file fxpkgfdokm.cpp.
266{
268
270
272
273 //
274 // Now that the IRP has returned to us, we modify what the bus driver
275 // set up.
276 //
279 }
280
282
284}
VOID HandleQueryCapabilitiesCompletion(__inout FxIrp *Irp)
Definition: fxpkgfdo.cpp:613
VOID HandleQueryCapabilities(__inout FxIrp *Irp)
Definition: fxpkgfdo.cpp:572
◆ PnpQueryDeviceRelations()
|
private |
Definition at line 399 of file fxpkgfdo.cpp.
421{
424
426
428 "Entering QueryDeviceRelations handler, "
429 "type %!DEVICE_RELATION_TYPE!",
430 type);
431
433
434
435 //
436 // Set up the type of relations.
437 //
441
442 //
443 // STATUS_NOT_SUPPORTED is a special value. It means that
444 // HandleQueryBusRelations did not modify the irp at all and it should
445 // be sent off as is.
446 //
448 //
449 // We set status to STATUS_SUCCESS so that we send the requqest down
450 // the stack in the comparison below.
451 //
453 }
454 break;
455
458
459 //
460 // STATUS_NOT_SUPPORTED is a special value. It means that
461 // HandleQueryDeviceRelations did not modify the irp at all and it should
462 // be sent off as is.
463 //
465 //
466 // We set status to STATUS_SUCCESS so that we send the requqest down
467 // the stack in the comparison below.
468 //
470 }
471 break;
472 }
473
476 }
477 else {
479 }
480
482 "Exiting QueryDeviceRelations handler, status %!STATUS!",
483 status);
484
486}
_Must_inspect_result_ NTSTATUS HandleQueryDeviceRelations(__inout FxIrp *Irp, __inout FxRelatedDeviceList *List)
Definition: fxpkgpnp.cpp:996
_Must_inspect_result_ NTSTATUS HandleQueryBusRelations(__inout FxIrp *Irp)
Definition: fxpkgpnp.cpp:758
enum _DEVICE_RELATION_TYPE DEVICE_RELATION_TYPE
◆ PnpSendStartDeviceDownTheStackOverload()
Implements FxPkgPnp.
Definition at line 919 of file fxpkgfdo.cpp.
934{
935 //
936 // We will re-set the pending pnp irp when the start irp returns
937 //
939 PCM_RESOURCE_LIST pWdmRaw, pWdmTranslated;
943
946
947 //
948 // Always setup the irp to be sent down the stack. In case of an error,
949 // this does no harm and it keeps everything simple.
950 //
952
953 //
954 // If the driver registered for a callback to remove its added resources
955 // and there are resources to remove, call the driver and set the next
956 // stack location to the filtered resources lists
957 //
960
961 //
962 // Since we reuse these 2 fields for both the removal and the normal
963 // reporting (and can then be subsequently reused on a restart), we
964 // set the changed status back to FALSE.
965 //
968
971
975 }
976
982 );
983 }
984
987
989
992
993 //
994 // Allocate the raw and translated resources. Upon failure for
995 // either, fail the start irp. We allocate from NonPagedPool
996 // because we are going to free the list in a completion routine
997 // which maybe running at an IRQL > PASSIVE_LEVEL.
998 //
1000 pContext->ResourcesRaw =
1002
1005 }
1006 }
1007
1009 pContext->ResourcesTranslated =
1011
1014 }
1015 }
1016
1018 //
1019 // We copied to the next stack location at the start
1020 //
1022 pContext->ResourcesRaw);
1024 pContext->ResourcesTranslated);
1025
1026 //
1027 // Completion routine will free the resource list
1028 // allocations.
1029 //
1030 setFilteredCompletion = TRUE;
1031 }
1032 else {
1033 //
1034 // Allocation failure. The destructor will free any
1035 // outstanding allocations.
1036 //
1037 delete pContext;
1038 }
1039 }
1040 }
1041 }
1042 else {
1044 }
1045
1047 //
1048 // The completion of the start irp will move the state machine into a new
1049 // state.
1050 //
1051 // After calling IoSetCompletionRoutineEx the driver must call
1052 // IoCallDriver, otherwise a memory leak would occur. So call this API
1053 // as close to IoCallDriver as possible to avoid failure paths.
1054 //
1055 if (setFilteredCompletion) {
1060 pContext);
1061 }
1062 else {
1066 this);
1067 }
1068
1070 }
1071 else {
1073 "PNP start preprocessing failed with %!STATUS!",
1074 status);
1075
1076 //
1077 // Move the state machine to the failed state.
1078 //
1079 // Process the event *before* completing the irp so that this even is in
1080 // the queue before the device remove event which will be be processed
1081 // right after the start irp has been completed.
1082 //
1084
1085 //
1086 // All states which handle the PnpEventStartDeviceFailed event
1087 // transition do not expect a pended start irp.
1088 //
1090 }
1091
1092 //
1093 // Indicate to the caller that the transition is asynchronous.
1094 //
1096}
_Must_inspect_result_ PCM_RESOURCE_LIST CreateWdmList(__in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType=PagedPool)
Definition: fxresourcecollection.cpp:366
_Must_inspect_result_ NTSTATUS BuildFromWdmList(__in PCM_RESOURCE_LIST ResourceList, __in UCHAR AccessFlags)
Definition: fxresourcecollection.cpp:289
PCM_RESOURCE_LIST GetParameterAllocatedResources()
Definition: fxirpum.cpp:843
VOID SetCompletionRoutineEx(__in MdDeviceObject DeviceObject, __in MdCompletionRoutine CompletionRoutine, __in PVOID Context, __in BOOLEAN InvokeOnSuccess=TRUE, __in BOOLEAN InvokeOnError=TRUE, __in BOOLEAN InvokeOnCancel=TRUE)
Definition: fxirpum.cpp:104
PCM_RESOURCE_LIST GetParameterAllocatedResourcesTranslated()
Definition: fxirpum.cpp:877
VOID SetParameterAllocatedResourcesTranslated(__in PCM_RESOURCE_LIST AllocatedResourcesTranslated)
Definition: fxirpum.cpp:897
VOID CopyCurrentIrpStackLocationToNext(VOID)
Definition: fxirpum.cpp:209
VOID SetParameterAllocatedResources(__in PCM_RESOURCE_LIST AllocatedResources)
Definition: fxirpum.cpp:869
static _Must_inspect_result_ NTSTATUS STDCALL _PnpFilteredStartDeviceCompletionRoutine(__in MdDeviceObject DeviceObject, __inout MdIrp Irp, __inout PVOID Context)
Definition: fxpkgfdo.cpp:1438
FxPnpDeviceRemoveAddedResources m_DeviceRemoveAddedResources
Definition: fxpkgfdo.hpp:67
_Must_inspect_result_ NTSTATUS Invoke(__in WDFDEVICE Device, __in WDFCMRESLIST ResourcesRaw, __in WDFCMRESLIST ResourcesTranslated)
Definition: fxpnpcallbacks.hpp:273
PFN_WDF_DEVICE_REMOVE_ADDED_RESOURCES m_Method
Definition: fxpnpcallbacks.hpp:262
PCM_RESOURCE_LIST ResourcesTranslated
Definition: fxpkgfdo.cpp:67
Definition: hwresource.cpp:163
◆ PostCreateDeviceInitialize()
| _Must_inspect_result_ NTSTATUS FxPkgFdo::PostCreateDeviceInitialize | ( | VOID | ) |
Definition at line 1524 of file fxpkgfdo.cpp.
1527{
1529
1533 }
1534
1535#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
1536 //
1537 // Allow device simulation framework to hook interrupt routines.
1538 //
1543 }
1544 }
1545
1546#endif
1547
1551 //
1552 // This will be released in the destructor
1553 //
1555 }
1556
1561 //
1562 // This will be released in the destructor
1563 //
1565 }
1566 }
1567
1568
1570}
_Must_inspect_result_ NTSTATUS AllocateTarget(_Out_ FxIoTarget **Target, _In_ BOOLEAN SelfTarget)
Definition: fxdevicebase.cpp:329
Definition: fxiotarget.hpp:210
_Must_inspect_result_ NTSTATUS QueryForDsfInterface(VOID)
Definition: fxpkgfdokm.cpp:455
_Must_inspect_result_ NTSTATUS PostCreateDeviceInitialize(VOID)
Definition: fxpkgpnp.cpp:1187
Referenced by FxDevice::FdoInitialize().
◆ PowerCheckDeviceTypeNPOverload()
|
privatevirtual |
◆ PowerCheckDeviceTypeOverload()
|
privatevirtual |
◆ PowerCheckParentOverload()
|
privatevirtual |
Definition at line 543 of file fdopower.cpp.
◆ PowerParentPowerDereference()
Implements FxPkgPnp.
Definition at line 569 of file fdopower.cpp.
◆ PowerReleasePendingDeviceIrp()
Definition at line 464 of file fdopower.cpp.
467{
469
471
472 UNREFERENCED_PARAMETER(IrpMustBePresent);
474
477
479 //
480 // We catch D0 irps on the way up, so complete it
481 //
483 }
484 else {
486
487 //
488 // We catch Dx irps on the way down, so send it on its way
489 //
490 // This will also release the remove lock
491 //
493 }
494 }
495}
DEVICE_POWER_STATE GetParameterPowerStateDeviceState()
Definition: fxirpum.cpp:695
MdIrp ClearPendingDevicePowerIrp(VOID)
Definition: fxpkgpnp.hpp:3069
◆ ProcessRemoveDeviceOverload()
|
privatevirtual |
Definition at line 1250 of file fxpkgfdo.cpp.
1253{
1255
1256 //
1257 // After this is called, any irp dispatched to FxDevice::DispatchWithLock
1258 // will fail with STATUS_INVALID_DEVICE_REQUEST.
1259 //
1261 Irp->GetIrp());
1262
1263 //
1264 // Cleanup the state machines and release the power thread.
1265 //
1267
1268 Irp->CopyCurrentIrpStackLocationToNext();
1270
1271 //
1272 // Detach and delete the device object.
1273 //
1274 DeleteDevice();
1275
1277}
VOID CleanupStateMachines(__in BOOLEAN ClenaupPnp)
Definition: fxpkgpnp.cpp:2066
static __inline VOID MxReleaseRemoveLockAndWait(__in MdRemoveLock RemoveLock, __in PVOID Tag)
Definition: mxgeneralkm.h:288
◆ QueryForDsfInterface()
|
private |
Definition at line 455 of file fxpkgfdokm.cpp.
458{
459// __REACTOS__ : not supported
460// WDF_DSF_INTERFACE dsfInterface;
461// NTSTATUS status;
462// BOOLEAN derefQI = FALSE;
463
464// RtlZeroMemory(&dsfInterface, sizeof(dsfInterface));
465
466// //
467// // Since there are some stacks that are not PnP re-entrant (like USBHUB,
468// // xpsp2), we specify that the QI goes only to our attached device and
469// // not to the top of the stack as a normal QI irp would.
470// //
471// // We also do this a preventative measure for other stacks we don't know
472// // about internally and do not have access to when testing.
473// //
474// status = m_Device->QueryForInterface(&GUID_WDF_DSF_INTERFACE,
475// (PINTERFACE) &dsfInterface,
476// sizeof(dsfInterface),
477// WDM_DSF_INTERFACE_V1_0,
478// NULL,
479// m_Device->GetAttachedDevice()
480// );
481
482// if (status == STATUS_NOT_SUPPORTED) {
483// DoTraceLevelMessage(
484// GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
485// "Lower stack does not have a DSF interface");
486// status = STATUS_SUCCESS;
487// goto Done;
488// }
489
490// if (!NT_SUCCESS(status)) {
491// DoTraceLevelMessage(
492// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
493// "Lower stack returned an error for query DSF interface, %!STATUS!",
494// status);
495// goto Done;
496// }
497
498// derefQI = TRUE;
499
500// //
501// // Basic run time checks.
502// //
503// if (dsfInterface.Interface.Version != WDM_DSF_INTERFACE_V1_0) {
504// status = STATUS_REVISION_MISMATCH;
505// DoTraceLevelMessage(
506// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
507// "Lower DSF stack supports v(%x), requested v(%x), %!STATUS!",
508// dsfInterface.Interface.Version,
509// WDM_DSF_INTERFACE_V1_0,
510// status);
511// goto Done;
512// }
513
514// //
515// // Ex functions should be both set or cleared.
516// // Active/Inactive functions should be both set or cleared.
517// // Ex function must be present.
518// // Note: !!(ptr) expression below converts ptr value to true/false value.
519// // I.e., ptr==NULL to false and ptr!=NULL to true.
520// //
521// if (!((!!(dsfInterface.IoConnectInterruptEx) ==
522// !!(dsfInterface.IoDisconnectInterruptEx)) &&
523// (!!(dsfInterface.IoReportInterruptActive) ==
524// !!(dsfInterface.IoReportInterruptInactive)) &&
525// (dsfInterface.IoConnectInterruptEx != NULL)
526// )) {
527// status = STATUS_DATA_ERROR;
528// DoTraceLevelMessage(
529// GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
530// "Function mismatch detected in DSF interface, %!STATUS!",
531// status);
532// goto Done;
533// }
534
535// //
536// // Info is correct.
537// //
538// m_IoConnectInterruptEx = dsfInterface.IoConnectInterruptEx;
539// m_IoDisconnectInterruptEx = dsfInterface.IoDisconnectInterruptEx;
540
541// //
542// // If DSF interface provides active/inactive functions then use them
543// //
544// if (dsfInterface.IoReportInterruptActive != NULL)
545// {
546// m_IoReportInterruptActive = dsfInterface.IoReportInterruptActive;
547// m_IoReportInterruptInactive = dsfInterface.IoReportInterruptInactive;
548// }
549
550// Done:
551
552// //
553// // The contract with the DSF layer is to release the interface right away;
554// // the embedded interrupt function ptrs will be valid until this driver is
555// // unloaded.
556// //
557// if (derefQI) {
558// dsfInterface.Interface.InterfaceDereference(dsfInterface.Interface.Context);
559// }
560
561// return status;
563}
Referenced by PostCreateDeviceInitialize().
◆ QueryForPowerThread()
|
privatevirtual |
Implements FxPkgPnp.
Definition at line 1387 of file fxpkgfdo.cpp.
1403{
1405
1406 //
1407 // Query down the stack to see if a lower device already created a thread.
1408 // Do NOT send this to the top of the stack, it is sent to the attached
1409 // device b/c we need the thread from a device below us b/c its lifetime
1410 // will outlast this device's.
1411 //
1415 1,
1416 NULL,
1418
1420 //
1421 // A lower thread exists, use it
1422 //
1424 }
1425 else {
1426 //
1427 // No thread exists yet, attempt to create our own
1428 //
1430 }
1431
1433}
_Must_inspect_result_ NTSTATUS QueryForInterface(__in const GUID *InterfaceType, __out PINTERFACE Interface, __in USHORT Size, __in USHORT Version, __in PVOID InterfaceSpecificData, __in_opt MdDeviceObject TargetDevice=NULL)
Definition: fxdevicebasekm.cpp:33
_Must_inspect_result_ NTSTATUS CreatePowerThread(VOID)
Definition: fxpkgpnp.cpp:5125
POWER_THREAD_INTERFACE m_PowerThreadInterface
Definition: fxpkgpnp.hpp:4213
static const GUID GUID_POWER_THREAD_INTERFACE
Definition: fxpkgpnp.hpp:4282
◆ QueryForReenumerationInterface()
Implements FxPkgPnp.
Definition at line 1307 of file fxpkgfdo.cpp.
1310{
1313
1315
1317 //
1318 // Already got it, just return. This function can be called again during
1319 // stop -> start, so we must check.
1320 //
1321 return;
1322 }
1323
1327
1328 //
1329 // Since there are some stacks that are not PnP re-entrant
1330
1331 // we specify that the QI goes only to our attached device and
1332 // not to the top of the stack as a normal QI irp would. For the
1333 // reenumerate self interface, having someone on top of us filter the
1334 // IRP makes no sense anyways.
1335 //
1336 // We also do this as a preventative measure for other stacks we don't know
1337 // about internally and do not have access to when testing.
1338 //
1342 1,
1343 NULL,
1345 );
1346
1347 //
1348 // Failure to get this interface is not fatal.
1349 // Note that an implicit reference has been taken on the interface. We
1350 // must release the reference when we are done with the interface.
1351 //
1353}
Definition: miniport.h:120
◆ RaiseDevicePower()
|
private |
Definition at line 353 of file fdopower.cpp.
356{
357 Irp->MarkIrpPending();
358 Irp->CopyCurrentIrpStackLocationToNext();
361 this);
362
364
366}
static MdCompletionRoutineType RaiseDevicePowerCompletion
Definition: fxpkgfdo.hpp:454
Referenced by DispatchDeviceSetPower().
◆ RegisterCallbacks()
| _Must_inspect_result_ NTSTATUS FxPkgFdo::RegisterCallbacks | ( | __in PWDF_FDO_EVENT_CALLBACKS | DispatchTable | ) |
Definition at line 796 of file fxpkgfdo.cpp.
799{
800 //
801 // Walk the table, and only update the pkg table *if* the dispatch
802 // table has a non-null entry.
803 //
805 DispatchTable->EvtDeviceFilterAddResourceRequirements;
807 DispatchTable->EvtDeviceFilterRemoveResourceRequirements;
809 DispatchTable->EvtDeviceRemoveAddedResources;
810
812}
_In_ PWDFDEVICE_INIT _In_ PWDF_PDO_EVENT_CALLBACKS DispatchTable
Definition: wdfpdo.h:248
Referenced by FxDevice::FdoInitialize().
◆ ReleaseReenumerationInterface()
Implements FxPkgPnp.
Definition at line 1356 of file fxpkgfdo.cpp.
1373{
1375
1377
1379
1382 }
1383}
PINTERFACE_DEREFERENCE InterfaceDereference
Definition: miniport.h:125
◆ SendIrpSynchronously()
|
privatevirtual |
Definition at line 248 of file fxpkgfdo.cpp.
Referenced by _PnpQueryPnpDeviceState(), PnpFilterResourceRequirements(), and PnpQueryCapabilities().
◆ SetFilter()
| _Must_inspect_result_ NTSTATUS FxPkgFdo::SetFilter | ( | __in BOOLEAN | Value | ) |
Definition at line 892 of file fxpkgfdo.cpp.
913{
916}
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
Referenced by FxDevice::SetFilter().
Member Data Documentation
◆ _SystemPowerS0Completion
|
staticprotected |
Definition at line 461 of file fxpkgfdo.hpp.
Referenced by DispatchSystemSetPower().
◆ _SystemPowerSxCompletion
|
staticprotected |
Definition at line 465 of file fxpkgfdo.hpp.
Referenced by DispatchSystemSetPower().
◆ m_DefaultDeviceList
| FxChildList* FxPkgFdo::m_DefaultDeviceList |
Definition at line 40 of file fxpkgfdo.hpp.
Referenced by CreateDefaultDeviceList(), FxPkgFdo(), if(), and ~FxPkgFdo().
◆ m_DefaultTarget
| FxIoTarget* FxPkgFdo::m_DefaultTarget |
Definition at line 47 of file fxpkgfdo.hpp.
Referenced by FxPkgFdo(), FxDevice::GetDefaultIoTarget(), PostCreateDeviceInitialize(), and ~FxPkgFdo().
◆ m_DeviceFilterAddResourceRequirements
|
private |
Definition at line 63 of file fxpkgfdo.hpp.
Referenced by PnpFilterResourceRequirements(), and RegisterCallbacks().
◆ m_DeviceFilterRemoveResourceRequirements
|
private |
Definition at line 65 of file fxpkgfdo.hpp.
Referenced by PnpFilterResourceRequirements(), and RegisterCallbacks().
◆ m_DeviceRemoveAddedResources
|
private |
Definition at line 67 of file fxpkgfdo.hpp.
Referenced by PnpSendStartDeviceDownTheStackOverload(), and RegisterCallbacks().
◆ m_FdoPnpFunctionTable
|
staticprivate |
Definition at line 74 of file fxpkgfdo.hpp.
Referenced by GetDispatchPnp().
◆ m_FdoPowerFunctionTable
|
staticprivate |
Initial value:
=
{
}
static _Must_inspect_result_ NTSTATUS _DispatchSetPower(__inout FxPkgPnp *This, __in FxIrp *Irp)
Definition: fdopower.cpp:90
static _Must_inspect_result_ NTSTATUS _DispatchQueryPower(__inout FxPkgPnp *This, __in FxIrp *Irp)
Definition: fdopower.cpp:123
static _Must_inspect_result_ NTSTATUS _DispatchWaitWake(__inout FxPkgPnp *This, __inout FxIrp *Irp)
Definition: fxpkgpnp.cpp:2400
Definition at line 79 of file fxpkgfdo.hpp.
Referenced by GetDispatchPower().
◆ m_Filter
|
private |
Definition at line 69 of file fxpkgfdo.hpp.
Referenced by FxPkgFdo(), IsFilter(), and SetFilter().
◆ m_SelfTarget
| FxIoTargetSelf* FxPkgFdo::m_SelfTarget |
Definition at line 53 of file fxpkgfdo.hpp.
Referenced by FxPkgFdo(), FxDevice::GetSelfIoTarget(), PostCreateDeviceInitialize(), and ~FxPkgFdo().
◆ m_StaticDeviceList
| FxChildList* FxPkgFdo::m_StaticDeviceList |
Definition at line 42 of file fxpkgfdo.hpp.
Referenced by FxPkgFdo(), Initialize(), FxPkgPdo::Initialize(), and ~FxPkgFdo().
◆ m_SurpriseRemoveAndReenumerateSelfInterface
|
private |
Definition at line 57 of file fxpkgfdo.hpp.
Referenced by AskParentToRemoveAndReenumerate(), FxPkgFdo(), QueryForReenumerationInterface(), and ReleaseReenumerationInterface().
◆ RaiseDevicePowerCompletion
|
static |
Definition at line 454 of file fxpkgfdo.hpp.
Referenced by RaiseDevicePower().
The documentation for this class was generated from the following files:
- sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgfdo.hpp
- sdk/lib/drivers/wdf/shared/irphandlers/pnp/fdopower.cpp
- sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgfdo.cpp
- sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgfdokm.cpp
- sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgfdoum.cpp
