ReactOS 0.4.17-dev-1196-gb6224c3
pnp.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS USB Hub Driver
3 * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4 * PURPOSE: USBHub plug and play functions
5 * COPYRIGHT: Copyright 2017 Vadim Galyant <vgal@rambler.ru>
6 */
7
8#include "usbhub.h"
9
10#define NDEBUG
11#include <debug.h>
12
13#define NDEBUG_USBHUB_PNP
14#define NDEBUG_USBHUB_ENUM
15#include "dbg_uhub.h"
16
17NTSTATUS
18NTAPI
19USBH_IrpCompletion(IN PDEVICE_OBJECT DeviceObject,
20 IN PIRP Irp,
21 IN PVOID Context)
22{
23 PRKEVENT Event;
24
25 DPRINT("USBH_IrpCompletion: Irp - %p\n", Irp);
26
27 Event = Context;
28 KeSetEvent(Event, EVENT_INCREMENT, FALSE);
29 return STATUS_MORE_PROCESSING_REQUIRED;
30}
31
32NTSTATUS
33NTAPI
34USBH_HubPnPIrpComplete(IN PDEVICE_OBJECT DeviceObject,
35 IN PIRP Irp,
36 IN PVOID Context)
37{
38 PUSBHUB_FDO_EXTENSION HubExtension;
39
40 DPRINT("USBH_HubPnPIrpComplete: Irp - %p\n", Irp);
41
42 HubExtension = Context;
43
44 if (!NT_SUCCESS(Irp->IoStatus.Status))
45 {
46 DPRINT1("USBH_HubPnPIrpComplete: Irp failed - %lX\n", Irp->IoStatus.Status);
47 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
48 }
49
50 Irp->IoStatus.Status = STATUS_MORE_PROCESSING_REQUIRED;
51
52 KeSetEvent(&HubExtension->LowerDeviceEvent, EVENT_INCREMENT, FALSE);
53
54 return STATUS_MORE_PROCESSING_REQUIRED;
55}
56
57NTSTATUS
58NTAPI
59USBH_QueryCapsComplete(IN PDEVICE_OBJECT DeviceObject,
60 IN PIRP Irp,
61 IN PVOID Context)
62{
63 PIO_STACK_LOCATION IoStack;
64 PDEVICE_CAPABILITIES Capabilities;
65
66 DPRINT("USBH_QueryCapsComplete: ... \n");
67
68 ASSERT(NT_SUCCESS(Irp->IoStatus.Status));
69
70 if (Irp->PendingReturned)
71 {
72 IoMarkIrpPending(Irp);
73 }
74
75 IoStack= IoGetCurrentIrpStackLocation(Irp);
76 Capabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
77
78 Capabilities->SurpriseRemovalOK = 1;
79
80 return STATUS_CONTINUE_COMPLETION;
81}
82
83NTSTATUS
84NTAPI
85USBHUB_GetBusInterface(IN PDEVICE_OBJECT DeviceObject,
86 OUT PUSB_BUS_INTERFACE_HUB_V5 BusInterface)
87{
88 PIRP Irp;
89 NTSTATUS Status;
90 PIO_STACK_LOCATION IoStack;
91 KEVENT Event;
92
93 DPRINT("USBHUB_GetBusInterface: ... \n");
94
95 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
96
97 if (!Irp)
98 {
99 DPRINT1("USBHUB_GetBusInterface: IoAllocateIrp() failed\n");
100 return STATUS_INSUFFICIENT_RESOURCES;
101 }
102
103 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
104
105 KeInitializeEvent(&Event, NotificationEvent, FALSE);
106
107 IoSetCompletionRoutine(Irp,
108 USBH_IrpCompletion,
109 &Event,
110 TRUE,
111 TRUE,
112 TRUE);
113
114 IoStack = IoGetNextIrpStackLocation(Irp);
115
116 IoStack->MajorFunction = IRP_MJ_PNP;
117 IoStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
118
119 IoStack->Parameters.QueryInterface.InterfaceType = &USB_BUS_INTERFACE_HUB_GUID;
120 IoStack->Parameters.QueryInterface.Size = sizeof(USB_BUS_INTERFACE_HUB_V5);
121 IoStack->Parameters.QueryInterface.Version = USB_BUSIF_HUB_VERSION_5;
122 IoStack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterface;
123 IoStack->Parameters.QueryInterface.InterfaceSpecificData = DeviceObject;
124
125 Status = IoCallDriver(DeviceObject, Irp);
126
127 if (Status == STATUS_PENDING)
128 {
129 KeWaitForSingleObject(&Event,
130 Suspended,
131 KernelMode,
132 FALSE,
133 NULL);
134
135 Status = Irp->IoStatus.Status;
136 }
137
138 IoFreeIrp(Irp);
139
140 return Status;
141}
142
143NTSTATUS
144NTAPI
145USBHUB_GetBusInterfaceUSBDI(IN PDEVICE_OBJECT DeviceObject,
146 OUT PUSB_BUS_INTERFACE_USBDI_V2 BusInterfaceUSBDI)
147{
148 PIRP Irp;
149 NTSTATUS Status;
150 PIO_STACK_LOCATION IoStack;
151 KEVENT Event;
152
153 DPRINT("USBHUB_GetBusInterfaceUSBDI: ... \n");
154
155 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
156
157 if (!Irp)
158 {
159 DPRINT1("USBHUB_GetBusInterfaceUSBDI: IoAllocateIrp() failed\n");
160 return STATUS_INSUFFICIENT_RESOURCES;
161 }
162
163 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
164
165 KeInitializeEvent(&Event, NotificationEvent, FALSE);
166
167 IoSetCompletionRoutine(Irp,
168 USBH_IrpCompletion,
169 &Event,
170 TRUE,
171 TRUE,
172 TRUE);
173
174 IoStack = IoGetNextIrpStackLocation(Irp);
175
176 IoStack->MajorFunction = IRP_MJ_PNP;
177 IoStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
178
179 IoStack->Parameters.QueryInterface.InterfaceType = &USB_BUS_INTERFACE_USBDI_GUID;
180 IoStack->Parameters.QueryInterface.Size = sizeof(USB_BUS_INTERFACE_USBDI_V2);
181 IoStack->Parameters.QueryInterface.Version = USB_BUSIF_USBDI_VERSION_2;
182 IoStack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterfaceUSBDI;
183 IoStack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
184
185 Status = IoCallDriver(DeviceObject, Irp);
186
187 if (Status == STATUS_PENDING)
188 {
189 KeWaitForSingleObject(&Event,
190 Suspended,
191 KernelMode,
192 FALSE,
193 NULL);
194
195 Status = Irp->IoStatus.Status;
196 }
197
198 IoFreeIrp(Irp);
199
200 return Status;
201}
202
203VOID
204NTAPI
205USBH_QueryCapabilities(IN PDEVICE_OBJECT DeviceObject,
206 IN PDEVICE_CAPABILITIES DeviceCapabilities)
207{
208 PIRP Irp;
209 PIO_STACK_LOCATION IoStack;
210 KEVENT Event;
211
212 DPRINT("USBH_QueryCapabilities: ... \n");
213
214 RtlZeroMemory(DeviceCapabilities, sizeof(DEVICE_CAPABILITIES));
215
216 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
217
218 if (!Irp)
219 {
220 DPRINT1("USBH_QueryCapabilities: IoAllocateIrp() failed\n");
221 return;
222 }
223
224 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
225
226 KeInitializeEvent(&Event, NotificationEvent, FALSE);
227
228 IoSetCompletionRoutine(Irp,
229 USBH_IrpCompletion,
230 &Event,
231 TRUE,
232 TRUE,
233 TRUE);
234
235 IoStack = IoGetNextIrpStackLocation(Irp);
236
237 IoStack->MajorFunction = IRP_MJ_PNP;
238 IoStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
239
240 IoStack->Parameters.DeviceCapabilities.Capabilities = DeviceCapabilities;
241 IoStack->Parameters.DeviceCapabilities.Capabilities->Size = sizeof(DEVICE_CAPABILITIES);
242 IoStack->Parameters.DeviceCapabilities.Capabilities->Version = 1;
243 IoStack->Parameters.DeviceCapabilities.Capabilities->Address = MAXULONG;
244 IoStack->Parameters.DeviceCapabilities.Capabilities->UINumber = MAXULONG;
245
246 if (IoCallDriver(DeviceObject, Irp) == STATUS_PENDING)
247 {
248 KeWaitForSingleObject(&Event,
249 Suspended,
250 KernelMode,
251 FALSE,
252 NULL);
253 }
254
255 IoFreeIrp(Irp);
256}
257
258NTSTATUS
259NTAPI
260USBH_OpenConfiguration(IN PUSBHUB_FDO_EXTENSION HubExtension)
261{
262 PUSB_INTERFACE_DESCRIPTOR Pid;
263 PURB Urb;
264 NTSTATUS Status;
265 USBD_INTERFACE_LIST_ENTRY InterfaceList[2] = {{NULL, NULL}, {NULL, NULL}};
266
267 DPRINT("USBH_OpenConfiguration ... \n");
268
269 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB &&
270 HubExtension->LowerPDO != HubExtension->RootHubPdo)
271 {
272 Pid = USBD_ParseConfigurationDescriptorEx(HubExtension->HubConfigDescriptor,
273 HubExtension->HubConfigDescriptor,
274 -1,
275 -1,
276 USB_DEVICE_CLASS_HUB,
277 -1,
278 2);
279
280 if (Pid)
281 {
282 HubExtension->HubFlags |= USBHUB_FDO_FLAG_MULTIPLE_TTS;
283 }
284 else
285 {
286 Pid = USBD_ParseConfigurationDescriptorEx(HubExtension->HubConfigDescriptor,
287 HubExtension->HubConfigDescriptor,
288 -1,
289 -1,
290 USB_DEVICE_CLASS_HUB,
291 -1,
292 1);
293
294 if (Pid)
295 {
296 goto Next;
297 }
298
299 Pid = USBD_ParseConfigurationDescriptorEx(HubExtension->HubConfigDescriptor,
300 HubExtension->HubConfigDescriptor,
301 -1,
302 -1,
303 USB_DEVICE_CLASS_HUB,
304 -1,
305 0);
306 }
307 }
308 else
309 {
310 Pid = USBD_ParseConfigurationDescriptorEx(HubExtension->HubConfigDescriptor,
311 HubExtension->HubConfigDescriptor,
312 -1,
313 -1,
314 USB_DEVICE_CLASS_HUB,
315 -1,
316 -1);
317 }
318
319 if (!Pid)
320 {
321 return STATUS_UNSUCCESSFUL;
322 }
323
324 Next:
325
326 if (Pid->bInterfaceClass != USB_DEVICE_CLASS_HUB)
327 {
328 return STATUS_UNSUCCESSFUL;
329 }
330
331 InterfaceList[0].InterfaceDescriptor = Pid;
332
333 Urb = USBD_CreateConfigurationRequestEx(HubExtension->HubConfigDescriptor,
334 InterfaceList);
335
336 if (!Urb)
337 {
338 return STATUS_INSUFFICIENT_RESOURCES;
339 }
340
341 Status = USBH_FdoSyncSubmitUrb(HubExtension->Common.SelfDevice, Urb);
342
343 if (NT_SUCCESS(Status))
344 {
345 RtlCopyMemory(&HubExtension->PipeInfo,
346 InterfaceList[0].Interface->Pipes,
347 sizeof(USBD_PIPE_INFORMATION));
348
349 HubExtension->ConfigHandle = Urb->UrbSelectConfiguration.ConfigurationHandle;
350 }
351
352 ExFreePool(Urb);
353
354 return Status;
355}
356
357NTSTATUS
358NTAPI
359USBD_Initialize20Hub(IN PUSBHUB_FDO_EXTENSION HubExtension)
360{
361 PUSB_BUSIFFN_INITIALIZE_20HUB Initialize20Hub;
362 ULONG TtCount;
363 PUSB_DEVICE_HANDLE DeviceHandle;
364
365 DPRINT("USBD_InitUsb2Hub ... \n");
366
367 Initialize20Hub = HubExtension->BusInterface.Initialize20Hub;
368
369 if (!Initialize20Hub)
370 {
371 return STATUS_NOT_IMPLEMENTED;
372 }
373
374 TtCount = 1;
375
376 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_MULTIPLE_TTS)
377 {
378 TtCount = HubExtension->HubDescriptor->bNumberOfPorts;
379 }
380
381 DeviceHandle = USBH_SyncGetDeviceHandle(HubExtension->LowerDevice);
382
383 return Initialize20Hub(HubExtension->BusInterface.BusContext,
384 DeviceHandle,
385 TtCount);
386}
387
388NTSTATUS
389NTAPI
390USBH_AbortInterruptPipe(IN PUSBHUB_FDO_EXTENSION HubExtension)
391{
392 struct _URB_PIPE_REQUEST * Urb;
393 NTSTATUS Status;
394
395 DPRINT("USBH_AbortInterruptPipe: HubExtension - %p\n", HubExtension);
396
397 Urb = ExAllocatePoolWithTag(NonPagedPool,
398 sizeof(struct _URB_PIPE_REQUEST),
399 USB_HUB_TAG);
400
401 if (!Urb)
402 {
403 return STATUS_INSUFFICIENT_RESOURCES;
404 }
405
406 RtlZeroMemory(Urb, sizeof(struct _URB_PIPE_REQUEST));
407
408 Urb->Hdr.Length = sizeof(struct _URB_PIPE_REQUEST);
409 Urb->Hdr.Function = URB_FUNCTION_ABORT_PIPE;
410 Urb->PipeHandle = HubExtension->PipeInfo.PipeHandle;
411
412 Status = USBH_FdoSyncSubmitUrb(HubExtension->Common.SelfDevice,
413 (PURB)Urb);
414
415 if (NT_SUCCESS(Status))
416 {
417 KeWaitForSingleObject(&HubExtension->StatusChangeEvent,
418 Suspended,
419 KernelMode,
420 FALSE,
421 NULL);
422 }
423
424 ExFreePoolWithTag(Urb, USB_HUB_TAG);
425
426 return Status;
427}
428
429VOID
430NTAPI
431USBH_FdoCleanup(IN PUSBHUB_FDO_EXTENSION HubExtension)
432{
433 PIRP IdleIrp = NULL;
434 PIRP WakeIrp = NULL;
435 PUSBHUB_PORT_DATA PortData;
436 PUSBHUB_PORT_PDO_EXTENSION PortExtension;
437 PIRP PortIdleIrp = NULL;
438 PIRP PortWakeIrp = NULL;
439 PVOID DeviceHandle;
440 NTSTATUS Status;
441 USHORT Port;
442 UCHAR NumberPorts;
443 KIRQL Irql;
444
445 DPRINT("USBH_FdoCleanup: HubExtension - %p\n", HubExtension);
446
447 USBD_UnRegisterRootHubCallBack(HubExtension);
448
449 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_STOPPING;
450
451 if (HubExtension->ResetRequestCount)
452 {
453 IoCancelIrp(HubExtension->ResetPortIrp);
454
455 KeWaitForSingleObject(&HubExtension->IdleEvent,
456 Suspended,
457 KernelMode,
458 FALSE,
459 NULL);
460 }
461
462 IoFreeIrp(HubExtension->ResetPortIrp);
463
464 HubExtension->ResetPortIrp = NULL;
465
466 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST)
467 {
468 KeWaitForSingleObject(&HubExtension->IdleEvent,
469 Suspended,
470 KernelMode,
471 FALSE,
472 NULL);
473 }
474
475 IoAcquireCancelSpinLock(&Irql);
476
477 if (HubExtension->PendingWakeIrp)
478 {
479 WakeIrp = HubExtension->PendingWakeIrp;
480 HubExtension->PendingWakeIrp = NULL;
481 }
482
483 if (HubExtension->PendingIdleIrp)
484 {
485 IdleIrp = HubExtension->PendingIdleIrp;
486 HubExtension->PendingIdleIrp = NULL;
487 }
488
489 IoReleaseCancelSpinLock(Irql);
490
491 if (WakeIrp)
492 {
493 USBH_HubCancelWakeIrp(HubExtension, WakeIrp);
494 }
495
496 USBH_HubCompletePortWakeIrps(HubExtension, STATUS_DELETE_PENDING);
497
498 if (IdleIrp)
499 {
500 USBH_HubCancelIdleIrp(HubExtension, IdleIrp);
501 }
502
503 if (InterlockedDecrement(&HubExtension->PendingRequestCount) > 0)
504 {
505 KeWaitForSingleObject(&HubExtension->PendingRequestEvent,
506 Suspended,
507 KernelMode,
508 FALSE,
509 NULL);
510 }
511
512 if (HubExtension->SCEIrp)
513 {
514 Status = USBH_AbortInterruptPipe(HubExtension);
515
516 if (!NT_SUCCESS(Status) && IoCancelIrp(HubExtension->SCEIrp))
517 {
518 KeWaitForSingleObject(&HubExtension->StatusChangeEvent,
519 Suspended,
520 KernelMode,
521 FALSE,
522 NULL);
523 }
524
525 IoFreeIrp(HubExtension->SCEIrp);
526
527 HubExtension->SCEIrp = NULL;
528 }
529
530 if (!HubExtension->PortData ||
531 !HubExtension->HubDescriptor)
532 {
533 goto Exit;
534 }
535
536 PortData = HubExtension->PortData;
537 NumberPorts = HubExtension->HubDescriptor->bNumberOfPorts;
538
539 for (Port = 0; Port < NumberPorts; Port++)
540 {
541 if (PortData[Port].DeviceObject)
542 {
543 PortExtension = PortData[Port].DeviceObject->DeviceExtension;
544
545 IoAcquireCancelSpinLock(&Irql);
546
547 PortIdleIrp = PortExtension->IdleNotificationIrp;
548
549 if (PortIdleIrp)
550 {
551 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_IDLE_NOTIFICATION;
552 PortExtension->IdleNotificationIrp = NULL;
553
554 if (PortIdleIrp->Cancel)
555 {
556 PortIdleIrp = NULL;
557 }
558
559 if (PortIdleIrp)
560 {
561 IoSetCancelRoutine(PortIdleIrp, NULL);
562 }
563 }
564
565 PortWakeIrp = PortExtension->PdoWaitWakeIrp;
566
567 if (PortWakeIrp)
568 {
569 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_WAIT_WAKE;
570 PortExtension->PdoWaitWakeIrp = NULL;
571
572 if (PortWakeIrp->Cancel || !IoSetCancelRoutine(PortWakeIrp, NULL))
573 {
574 PortWakeIrp = NULL;
575
576 if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
577 {
578 KeSetEvent(&HubExtension->PendingRequestEvent,
579 EVENT_INCREMENT,
580 FALSE);
581 }
582 }
583 }
584
585 IoReleaseCancelSpinLock(Irql);
586
587 if (PortIdleIrp)
588 {
589 PortIdleIrp->IoStatus.Status = STATUS_CANCELLED;
590 IoCompleteRequest(PortIdleIrp, IO_NO_INCREMENT);
591 }
592
593 if (PortWakeIrp)
594 {
595 USBH_CompletePowerIrp(HubExtension,
596 PortWakeIrp,
597 STATUS_CANCELLED);
598 }
599
600 if (!(PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_POWER_D3))
601 {
602 DeviceHandle = InterlockedExchangePointer(&PortExtension->DeviceHandle,
603 NULL);
604
605 if (DeviceHandle)
606 {
607 USBD_RemoveDeviceEx(HubExtension, DeviceHandle, 0);
608 }
609
610 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_POWER_D3;
611 }
612 }
613
614 USBH_SyncDisablePort(HubExtension, Port + 1);
615 }
616
617Exit:
618
619 if (HubExtension->SCEBitmap)
620 {
621 ExFreePoolWithTag(HubExtension->SCEBitmap, USB_HUB_TAG);
622 }
623
624 if (HubExtension->HubDescriptor)
625 {
626 ExFreePoolWithTag(HubExtension->HubDescriptor, USB_HUB_TAG);
627 }
628
629 if (HubExtension->HubConfigDescriptor)
630 {
631 ExFreePoolWithTag(HubExtension->HubConfigDescriptor, USB_HUB_TAG);
632 }
633
634 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_DEVICE_STARTED;
635
636 HubExtension->HubDescriptor = NULL;
637 HubExtension->HubConfigDescriptor = NULL;
638
639 HubExtension->SCEIrp = NULL;
640 HubExtension->SCEBitmap = NULL;
641}
642
643NTSTATUS
644NTAPI
645USBH_StartHubFdoDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
646 IN PIRP Irp)
647{
648 NTSTATUS Status;
649 ULONG DisableRemoteWakeup = 0;
650 ULONG HubCount = 0;
651 PUSB_DEVICE_HANDLE DeviceHandle;
652 USB_DEVICE_TYPE DeviceType;
653 DEVICE_CAPABILITIES DeviceCapabilities;
654 BOOLEAN IsBusPowered;
655 static WCHAR DisableWakeValueName[] = L"DisableRemoteWakeup";
656
657 DPRINT("USBH_StartHubFdoDevice: ... \n");
658
659 KeInitializeEvent(&HubExtension->IdleEvent, NotificationEvent, FALSE);
660 KeInitializeEvent(&HubExtension->ResetEvent, NotificationEvent, TRUE);
661 KeInitializeEvent(&HubExtension->PendingRequestEvent, NotificationEvent, FALSE);
662 KeInitializeEvent(&HubExtension->LowerDeviceEvent, NotificationEvent, FALSE);
663 KeInitializeEvent(&HubExtension->StatusChangeEvent, NotificationEvent, TRUE);
664 KeInitializeEvent(&HubExtension->RootHubNotificationEvent,
665 NotificationEvent,
666 TRUE);
667
668 KeInitializeSpinLock(&HubExtension->RelationsWorkerSpinLock);
669 KeInitializeSpinLock(&HubExtension->CheckIdleSpinLock);
670
671 KeInitializeSemaphore(&HubExtension->ResetDeviceSemaphore, 1, 1);
672 KeInitializeSemaphore(&HubExtension->HubPortSemaphore, 1, 1);
673 KeInitializeSemaphore(&HubExtension->HubSemaphore, 1, 1);
674
675 HubExtension->HubFlags = 0;
676 HubExtension->HubConfigDescriptor = NULL;
677 HubExtension->HubDescriptor = NULL;
678 HubExtension->SCEIrp = NULL;
679 HubExtension->SCEBitmap = NULL;
680 HubExtension->SystemPowerState.SystemState = PowerSystemWorking;
681 HubExtension->PendingRequestCount = 1;
682 HubExtension->ResetRequestCount = 0;
683 HubExtension->PendingIdleIrp = NULL;
684 HubExtension->PendingWakeIrp = NULL;
685
686 InitializeListHead(&HubExtension->PdoList);
687
688 HubExtension->HubFlags |= USBHUB_FDO_FLAG_WITEM_INIT;
689 InitializeListHead(&HubExtension->WorkItemList);
690 KeInitializeSpinLock(&HubExtension->WorkItemSpinLock);
691
692 IoCopyCurrentIrpStackLocationToNext(Irp);
693
694 IoSetCompletionRoutine(Irp,
695 USBH_HubPnPIrpComplete,
696 HubExtension,
697 TRUE,
698 TRUE,
699 TRUE);
700
701 if (IoCallDriver(HubExtension->LowerDevice, Irp) == STATUS_PENDING)
702 {
703 KeWaitForSingleObject(&HubExtension->LowerDeviceEvent,
704 Suspended,
705 KernelMode,
706 FALSE,
707 NULL);
708 }
709
710 HubExtension->RootHubPdo = NULL;
711
712 Status = USBH_SyncGetRootHubPdo(HubExtension->LowerDevice,
713 &HubExtension->RootHubPdo,
714 &HubExtension->RootHubPdo2);
715
716 if (!NT_SUCCESS(Status))
717 {
718 DPRINT1("USBH_SyncGetRootHubPdo() failed - %lX\n", Status);
719 goto ErrorExit;
720 }
721
722 USBH_WriteFailReasonID(HubExtension->LowerPDO, USBHUB_FAIL_NO_FAIL);
723
724 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED)
725 {
726 DPRINT1("USBH_StartHubFdoDevice: USBHUB_FDO_FLAG_DEVICE_FAILED - TRUE\n");
727 Status = STATUS_UNSUCCESSFUL;
728 goto ErrorExit;
729 }
730
731 HubExtension->HubFlags |= USBHUB_FDO_FLAG_REMOTE_WAKEUP;
732
733 Status = USBD_GetPdoRegistryParameter(HubExtension->LowerPDO,
734 &DisableRemoteWakeup,
735 sizeof(DisableRemoteWakeup),
736 DisableWakeValueName,
737 sizeof(DisableWakeValueName));
738
739 if (NT_SUCCESS(Status) && DisableRemoteWakeup)
740 {
741 DPRINT("USBH_StartHubFdoDevice: DisableRemoteWakeup - TRUE\n");
742 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_REMOTE_WAKEUP;
743 }
744
745 HubExtension->CurrentPowerState.DeviceState = PowerDeviceD0;
746
747 USBH_SyncGetHubCount(HubExtension->LowerDevice,
748 &HubCount);
749
750 Status = USBHUB_GetBusInterface(HubExtension->RootHubPdo,
751 &HubExtension->BusInterface);
752
753 if (!NT_SUCCESS(Status))
754 {
755 DPRINT1("USBH_StartHubFdoDevice: USBHUB_GetBusInterface() failed - %lX\n",
756 Status);
757 goto ErrorExit;
758 }
759
760 Status = USBHUB_GetBusInterfaceUSBDI(HubExtension->LowerDevice,
761 &HubExtension->BusInterfaceUSBDI);
762
763 if (!NT_SUCCESS(Status))
764 {
765 DPRINT1("USBH_StartHubFdoDevice: USBHUB_GetBusInterfaceUSBDI() failed - %lX\n",
766 Status);
767 goto ErrorExit;
768 }
769
770 DeviceHandle = USBH_SyncGetDeviceHandle(HubExtension->LowerDevice);
771
772 if (DeviceHandle)
773 {
774 Status = USBH_GetDeviceType(HubExtension, DeviceHandle, &DeviceType);
775
776 if (!NT_SUCCESS(Status))
777 {
778 DPRINT1("USBH_StartHubFdoDevice: USBH_GetDeviceType() failed - %lX\n",
779 Status);
780
781 goto ErrorExit;
782 }
783
784 if (DeviceType == Usb20Device)
785 {
786 HubExtension->HubFlags |= USBHUB_FDO_FLAG_USB20_HUB;
787 }
788 }
789
790 if (HubCount > USBHUB_MAX_CASCADE_LEVELS)
791 {
792 PUSBHUB_PORT_PDO_EXTENSION ParentPdoExtension;
793 PUSBHUB_FDO_EXTENSION ParentHubExtension;
794 USHORT ParentPort;
795 PUSBHUB_PORT_DATA PortData;
796
797 DPRINT1("USBH_StartHubFdoDevice: HubCount > 6 - %x\n", HubCount);
798
799 USBH_WriteFailReasonID(HubExtension->LowerPDO,
800 USBHUB_FAIL_NESTED_TOO_DEEPLY);
801
802 ParentPdoExtension = HubExtension->LowerPDO->DeviceExtension;
803 ParentHubExtension = ParentPdoExtension->HubExtension;
804
805 ParentPort = ParentPdoExtension->PortNumber - 1;
806 PortData = &ParentHubExtension->PortData[ParentPort];
807 PortData->ConnectionStatus = DeviceHubNestedTooDeeply;
808
809 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
810 }
811
812 USBH_QueryCapabilities(HubExtension->LowerDevice, &DeviceCapabilities);
813
814 HubExtension->SystemWake = DeviceCapabilities.SystemWake;
815 HubExtension->DeviceWake = DeviceCapabilities.DeviceWake;
816
817 RtlCopyMemory(HubExtension->DeviceState,
818 &DeviceCapabilities.DeviceState,
819 POWER_SYSTEM_MAXIMUM * sizeof(DEVICE_POWER_STATE));
820
821 Status = USBH_GetDeviceDescriptor(HubExtension->Common.SelfDevice,
822 &HubExtension->HubDeviceDescriptor);
823
824 if (!NT_SUCCESS(Status))
825 {
826 DPRINT1("USBH_StartHubFdoDevice: USBH_GetDeviceDescriptor() failed - %lX\n",
827 Status);
828 goto ErrorExit;
829 }
830
831 Status = USBH_GetConfigurationDescriptor(HubExtension->Common.SelfDevice,
832 &HubExtension->HubConfigDescriptor);
833
834 if (!NT_SUCCESS(Status))
835 {
836 DPRINT1("USBH_StartHubFdoDevice: USBH_GetConfigurationDescriptor() failed - %lX\n",
837 Status);
838 goto ErrorExit;
839 }
840
841 Status = USBH_SyncGetHubDescriptor(HubExtension);
842
843 if (!NT_SUCCESS(Status))
844 {
845 DPRINT1("USBH_StartHubFdoDevice: USBH_SyncGetHubDescriptor() failed - %lX\n",
846 Status);
847 goto ErrorExit;
848 }
849
850 IsBusPowered = USBH_HubIsBusPowered(HubExtension->Common.SelfDevice,
851 HubExtension->HubConfigDescriptor);
852
853 if (IsBusPowered)
854 {
855 /* bus-powered hub is allowed a maximum of 100 mA only for each port */
856 HubExtension->MaxPowerPerPort = 100;
857
858 /* can have 4 ports (4 * 100 mA) and 100 mA remains for itself;
859 expressed in 2 mA units (i.e., 250 = 500 mA). */
860 HubExtension->HubConfigDescriptor->MaxPower = 250;
861 }
862 else
863 {
864 /* self-powered hub is allowed a maximum of 500 mA for each port */
865 HubExtension->MaxPowerPerPort = 500;
866 }
867
868 Status = USBH_OpenConfiguration(HubExtension);
869
870 if (!NT_SUCCESS(Status))
871 {
872 DPRINT1("USBH_StartHubFdoDevice: USBH_OpenConfiguration() failed - %lX\n",
873 Status);
874 goto ErrorExit;
875 }
876
877 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB)
878 {
879 Status = USBD_Initialize20Hub(HubExtension);
880 }
881
882 if (!NT_SUCCESS(Status))
883 {
884 goto ErrorExit;
885 }
886
887 HubExtension->SCEIrp = IoAllocateIrp(HubExtension->Common.SelfDevice->StackSize,
888 FALSE);
889
890 HubExtension->ResetPortIrp = IoAllocateIrp(HubExtension->Common.SelfDevice->StackSize,
891 FALSE);
892
893 if (!HubExtension->SCEIrp || !HubExtension->ResetPortIrp)
894 {
895 Status = STATUS_INSUFFICIENT_RESOURCES;
896 goto ErrorExit;
897 }
898
899 HubExtension->SCEBitmapLength = HubExtension->PipeInfo.MaximumPacketSize;
900
901 HubExtension->SCEBitmap = ExAllocatePoolWithTag(NonPagedPool,
902 HubExtension->SCEBitmapLength,
903 USB_HUB_TAG);
904
905 if (!HubExtension->SCEBitmap)
906 {
907 Status = STATUS_INSUFFICIENT_RESOURCES;
908 goto ErrorExit;
909 }
910
911 RtlZeroMemory(HubExtension->SCEBitmap, HubExtension->SCEBitmapLength);
912
913 Status = USBH_SyncPowerOnPorts(HubExtension);
914
915 if (!NT_SUCCESS(Status))
916 {
917 goto ErrorExit;
918 }
919 else
920 {
921 USHORT Port;
922
923 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_STARTED;
924
925 for (Port = 1;
926 Port <= HubExtension->HubDescriptor->bNumberOfPorts;
927 Port++)
928 {
929 USBH_SyncClearPortStatus(HubExtension,
930 Port,
931 USBHUB_FEATURE_C_PORT_CONNECTION);
932 }
933 }
934
935 if (HubExtension->LowerPDO == HubExtension->RootHubPdo)
936 {
937 USBD_RegisterRootHubCallBack(HubExtension);
938 }
939 else
940 {
941 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DO_ENUMERATION;
942 USBH_SubmitStatusChangeTransfer(HubExtension);
943 }
944
945 goto Exit;
946
947 ErrorExit:
948
949 if (HubExtension->HubDescriptor)
950 {
951 ExFreePoolWithTag(HubExtension->HubDescriptor, USB_HUB_TAG);
952 HubExtension->HubDescriptor = NULL;
953 }
954
955 if (HubExtension->SCEIrp)
956 {
957 IoFreeIrp(HubExtension->SCEIrp);
958 HubExtension->SCEIrp = NULL;
959 }
960
961 if (HubExtension->ResetPortIrp)
962 {
963 IoFreeIrp(HubExtension->ResetPortIrp);
964 HubExtension->ResetPortIrp = NULL;
965 }
966
967 if (HubExtension->SCEBitmap)
968 {
969 ExFreePoolWithTag(HubExtension->SCEBitmap, USB_HUB_TAG);
970 HubExtension->SCEBitmap = NULL;
971 }
972
973 if (HubExtension->HubConfigDescriptor)
974 {
975 ExFreePoolWithTag(HubExtension->HubConfigDescriptor, USB_HUB_TAG);
976 HubExtension->HubConfigDescriptor = NULL;
977 }
978
979 Exit:
980
981 USBH_CompleteIrp(Irp, Status);
982
983 return Status;
984}
985
986NTSTATUS
987NTAPI
988USBH_FdoStartDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
989 IN PIRP Irp)
990{
991 NTSTATUS Status;
992
993 DPRINT("USBH_FdoStartDevice: HubExtension - %p\n", HubExtension);
994
995 HubExtension->RootHubPdo = NULL;
996
997 Status = USBH_SyncGetRootHubPdo(HubExtension->LowerDevice,
998 &HubExtension->RootHubPdo,
999 &HubExtension->RootHubPdo2);
1000
1001 if (NT_SUCCESS(Status))
1002 {
1003 if (HubExtension->RootHubPdo)
1004 {
1005 Status = USBH_StartHubFdoDevice(HubExtension, Irp);
1006 }
1007 else
1008 {
1009 DPRINT1("USBH_FdoStartDevice: FIXME. start ParentDevice\n");
1010 DbgBreakPoint();
1011 }
1012 }
1013 else
1014 {
1015 DPRINT1("USBH_FdoStartDevice: FIXME. USBH_SyncGetRootHubPdo return - %lX\n",
1016 Status);
1017
1018 DbgBreakPoint();
1019 USBH_CompleteIrp(Irp, Status);
1020 }
1021
1022 return Status;
1023}
1024
1025NTSTATUS
1026NTAPI
1027USBH_FdoQueryBusRelations(IN PUSBHUB_FDO_EXTENSION HubExtension,
1028 IN PIRP Irp)
1029{
1030 PDEVICE_RELATIONS DeviceRelations = NULL;
1031 NTSTATUS Status = STATUS_SUCCESS;
1032 LIST_ENTRY GhostPdoList;
1033 KIRQL OldIrql;
1034 PLIST_ENTRY PdoList;
1035 UCHAR NumberPorts;
1036 USHORT Port;
1037 USHORT GhostPort;
1038 PUSBHUB_PORT_DATA PortData;
1039 PDEVICE_OBJECT PdoDevice;
1040 PUSBHUB_PORT_PDO_EXTENSION PdoExtension;
1041 PUSBHUB_PORT_PDO_EXTENSION pdoExtension;
1042 NTSTATUS NtStatus;
1043 PVOID SerialNumber;
1044 PVOID DeviceHandle;
1045 USB_PORT_STATUS UsbPortStatus;
1046 PLIST_ENTRY Entry;
1047 ULONG Length;
1048
1049 DPRINT_ENUM("USBH_FdoQueryBusRelations: HubFlags - %lX\n",
1050 HubExtension->HubFlags);
1051
1052 if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED))
1053 {
1054 Status = STATUS_INVALID_DEVICE_STATE;
1055 goto RelationsWorker;
1056 }
1057
1058 if (!HubExtension->HubDescriptor)
1059 {
1060 Status = STATUS_UNSUCCESSFUL;
1061 goto RelationsWorker;
1062 }
1063
1064 if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_DO_ENUMERATION))
1065 {
1066 // FIXME: this delay makes devices discovery during early boot more reliable
1067 LARGE_INTEGER Interval;
1068 Status = STATUS_SUCCESS;
1069 IoInvalidateDeviceRelations(HubExtension->LowerPDO, BusRelations);
1070 Interval.QuadPart = -10000LL * 1000; // 1 sec.
1071 KeDelayExecutionThread(KernelMode, FALSE, &Interval);
1072
1073 DPRINT_ENUM("USBH_FdoQueryBusRelations: Skip enumeration\n");
1074 goto RelationsWorker;
1075 }
1076
1077 InterlockedIncrement(&HubExtension->PendingRequestCount);
1078
1079 KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
1080 Executive,
1081 KernelMode,
1082 FALSE,
1083 NULL);
1084
1085 NumberPorts = HubExtension->HubDescriptor->bNumberOfPorts;
1086 DPRINT_ENUM("USBH_FdoQueryBusRelations: NumberPorts - %x\n", NumberPorts);
1087
1088 Length = FIELD_OFFSET(DEVICE_RELATIONS, Objects) +
1089 NumberPorts * sizeof(PDEVICE_OBJECT);
1090
1091 if (Irp->IoStatus.Information)
1092 {
1093 DPRINT1("FIXME: leaking old bus relations\n");
1094 }
1095
1096 DeviceRelations = ExAllocatePoolWithTag(NonPagedPool, Length, USB_HUB_TAG);
1097
1098 if (!DeviceRelations)
1099 {
1100 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_NOT_ENUMERATED;
1101
1102 KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
1103 LOW_REALTIME_PRIORITY,
1104 1,
1105 FALSE);
1106
1107 if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
1108 {
1109 KeSetEvent(&HubExtension->PendingRequestEvent, EVENT_INCREMENT, FALSE);
1110 }
1111
1112 Status = STATUS_INSUFFICIENT_RESOURCES;
1113 goto RelationsWorker;
1114 }
1115
1116 RtlZeroMemory(DeviceRelations, Length);
1117
1118 DeviceRelations->Count = 0;
1119
1120EnumStart:
1121
1122 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_ESD_RECOVERING)
1123 {
1124 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_NOT_ENUMERATED;
1125
1126 KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
1127 LOW_REALTIME_PRIORITY,
1128 1,
1129 FALSE);
1130
1131 if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
1132 {
1133 KeSetEvent(&HubExtension->PendingRequestEvent, EVENT_INCREMENT, FALSE);
1134 }
1135
1136 Status = STATUS_SUCCESS;
1137 goto RelationsWorker;
1138 }
1139
1140 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_ENUM_POST_RECOVER;
1141
1142 for (Port = 1; Port <= NumberPorts; Port++)
1143 {
1144 PortData = &HubExtension->PortData[Port - 1];
1145
1146 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED)
1147 {
1148 continue;
1149 }
1150
1151 Status = USBH_SyncGetPortStatus(HubExtension,
1152 Port,
1153 &PortData->PortStatus,
1154 sizeof(USB_PORT_STATUS_AND_CHANGE));
1155
1156 if (!NT_SUCCESS(Status))
1157 {
1158 DPRINT_ENUM("USBH_FdoQueryBusRelations: Status - %X\n", Status);
1159 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
1160 DeviceRelations->Count = 0;
1161 goto EnumStart;
1162 }
1163
1164 DPRINT_ENUM("USBH_FdoQueryBusRelations: Port - %x, ConnectStatus - %x\n",
1165 Port,
1166 PortData->PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus);
1167
1168 PdoDevice = PortData->DeviceObject;
1169
1170 if (PortData->DeviceObject)
1171 {
1172 PdoExtension = PdoDevice->DeviceExtension;
1173
1174 if (PdoExtension->PortPdoFlags & USBHUB_PDO_FLAG_OVERCURRENT_PORT)
1175 {
1176 PortData->PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus = 1;
1177 }
1178 }
1179
1180 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED)
1181 {
1182 DPRINT1("USBH_FdoQueryBusRelations: DbgBreakPoint() \n");
1183 DbgBreakPoint();
1184 }
1185
1186 if (!PortData->PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus)
1187 {
1188 if (PdoDevice)
1189 {
1190 PdoExtension = PdoDevice->DeviceExtension;
1191
1192 PdoExtension->PortPdoFlags |= USBHUB_PDO_FLAG_DELETE_PENDING;
1193 PdoExtension->EnumFlags &= ~USBHUB_ENUM_FLAG_DEVICE_PRESENT;
1194
1195 SerialNumber = InterlockedExchangePointer((PVOID)&PdoExtension->SerialNumber,
1196 NULL);
1197
1198 if (SerialNumber)
1199 {
1200 ExFreePoolWithTag(SerialNumber, USB_HUB_TAG);
1201 }
1202
1203 DeviceHandle = InterlockedExchangePointer(&PdoExtension->DeviceHandle,
1204 NULL);
1205
1206 if (DeviceHandle)
1207 {
1208 USBD_RemoveDeviceEx(HubExtension, DeviceHandle, 0);
1209 USBH_SyncDisablePort(HubExtension, Port);
1210 }
1211 }
1212
1213 PortData->DeviceObject = NULL;
1214 PortData->ConnectionStatus = NoDeviceConnected;
1215 continue;
1216 }
1217
1218 if (PdoDevice)
1219 {
1220 ObReferenceObject(PdoDevice);
1221
1222 PdoDevice->Flags |= DO_POWER_PAGABLE;
1223 PdoDevice->Flags &= ~DO_DEVICE_INITIALIZING;
1224
1225 DeviceRelations->Objects[DeviceRelations->Count++] = PdoDevice;
1226
1227 PdoExtension = PdoDevice->DeviceExtension;
1228 PdoExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_POWER_D1_OR_D2;
1229
1230 continue;
1231 }
1232
1233 USBH_Wait(100);
1234
1235 NtStatus = USBH_SyncResetPort(HubExtension, Port);
1236
1237 if (!NT_SUCCESS(NtStatus))
1238 {
1239 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB)
1240 {
1241 PortData->DeviceObject = NULL;
1242 PortData->ConnectionStatus = NoDeviceConnected;
1243 continue;
1244 }
1245 }
1246 else
1247 {
1248 NtStatus = USBH_SyncGetPortStatus(HubExtension,
1249 Port,
1250 &PortData->PortStatus,
1251 sizeof(USB_PORT_STATUS_AND_CHANGE));
1252
1253 if (NT_SUCCESS(NtStatus))
1254 {
1255 ULONG ix = 0;
1256
1257 UsbPortStatus = PortData->PortStatus.PortStatus;
1258
1259 for (NtStatus = USBH_CreateDevice(HubExtension, Port, UsbPortStatus, ix);
1260 !NT_SUCCESS(NtStatus);
1261 NtStatus = USBH_CreateDevice(HubExtension, Port, UsbPortStatus, ix))
1262 {
1263 USBH_Wait(500);
1264
1265 if (ix >= 2)
1266 {
1267 break;
1268 }
1269
1270 if (PortData->DeviceObject)
1271 {
1272 IoDeleteDevice(PortData->DeviceObject);
1273 PortData->DeviceObject = NULL;
1274 PortData->ConnectionStatus = NoDeviceConnected;
1275 }
1276
1277 USBH_SyncResetPort(HubExtension, Port);
1278
1279 /* The device can come back at another speed after the reset */
1280 if (NT_SUCCESS(USBH_SyncGetPortStatus(HubExtension,
1281 Port,
1282 &PortData->PortStatus,
1283 sizeof(PortData->PortStatus))))
1284 {
1285 UsbPortStatus = PortData->PortStatus.PortStatus;
1286 }
1287
1288 ix++;
1289 }
1290
1291 if (NT_SUCCESS(NtStatus))
1292 {
1293 PdoExtension = PortData->DeviceObject->DeviceExtension;
1294
1295 if (!(PdoExtension->PortPdoFlags & USBHUB_PDO_FLAG_PORT_LOW_SPEED) &&
1296 !(PdoExtension->PortPdoFlags & USBHUB_PDO_FLAG_PORT_HIGH_SPEED) &&
1297 !(HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB))
1298 {
1299 DPRINT1("USBH_FdoQueryBusRelations: FIXME USBH_DeviceIs2xDualMode()\n");
1300
1301 if (0)//USBH_DeviceIs2xDualMode(PdoExtension))
1302 {
1303 PdoExtension->PortPdoFlags |= USBHUB_PDO_FLAG_HS_USB1_DUALMODE;
1304 }
1305 }
1306
1307 ObReferenceObject(PortData->DeviceObject);
1308
1309 DeviceRelations->Objects[DeviceRelations->Count] = PortData->DeviceObject;
1310
1311 PortData->DeviceObject->Flags |= DO_POWER_PAGABLE;
1312 PortData->DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
1313
1314 DeviceRelations->Count++;
1315
1316 PortData->ConnectionStatus = DeviceConnected;
1317
1318 continue;
1319 }
1320 }
1321 }
1322
1323 PortData->ConnectionStatus = DeviceFailedEnumeration;
1324
1325 if (NT_ERROR(USBH_SyncDisablePort(HubExtension, Port)))
1326 {
1327 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
1328 }
1329
1330 if (PortData->DeviceObject)
1331 {
1332 ObReferenceObject(PortData->DeviceObject);
1333 PortData->DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
1334 DeviceRelations->Objects[DeviceRelations->Count++] = PortData->DeviceObject;
1335 }
1336 }
1337
1338 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_NOT_ENUMERATED;
1339
1340 KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
1341 LOW_REALTIME_PRIORITY,
1342 1,
1343 FALSE);
1344
1345 if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
1346 {
1347 KeSetEvent(&HubExtension->PendingRequestEvent, EVENT_INCREMENT, FALSE);
1348 }
1349
1350RelationsWorker:
1351
1352 Irp->IoStatus.Status = Status;
1353
1354 if (!NT_SUCCESS(Status))
1355 {
1356 //Irp->IoStatus.Information = 0;
1357
1358 if (DeviceRelations)
1359 {
1360 ExFreePoolWithTag(DeviceRelations, USB_HUB_TAG);
1361 }
1362
1363 USBH_CompleteIrp(Irp, Status);
1364
1365 return Status;
1366 }
1367
1368 KeAcquireSpinLock(&HubExtension->RelationsWorkerSpinLock, &OldIrql);
1369
1370 if (DeviceRelations && DeviceRelations->Count)
1371 {
1372 for (Port = 0; Port < DeviceRelations->Count; Port++)
1373 {
1374 PdoDevice = DeviceRelations->Objects[Port];
1375 Entry = HubExtension->PdoList.Flink;
1376
1377 while (Entry != &HubExtension->PdoList)
1378 {
1379 pdoExtension = CONTAINING_RECORD(Entry,
1380 USBHUB_PORT_PDO_EXTENSION,
1381 PortLink);
1382
1383 if (pdoExtension == PdoDevice->DeviceExtension)
1384 {
1385 PdoExt(PdoDevice)->EnumFlags |= USBHUB_ENUM_FLAG_GHOST_DEVICE;
1386 goto PortNext;
1387 }
1388
1389 Entry = Entry->Flink;
1390 }
1391
1392 PdoExt(PdoDevice)->EnumFlags |= USBHUB_ENUM_FLAG_DEVICE_PRESENT;
1393
1394 PortNext:;
1395 }
1396
1397 for (Port = 0; Port < DeviceRelations->Count; Port++)
1398 {
1399 PdoDevice = DeviceRelations->Objects[Port];
1400
1401 if (PdoExt(PdoDevice)->EnumFlags & USBHUB_ENUM_FLAG_GHOST_DEVICE)
1402 {
1403 for (GhostPort = Port;
1404 GhostPort < DeviceRelations->Count - 1;
1405 GhostPort++)
1406 {
1407 DeviceRelations->Objects[GhostPort] =
1408 DeviceRelations->Objects[GhostPort + 1];
1409 }
1410
1411 ObDereferenceObject(PdoDevice);
1412
1413 DeviceRelations->Count--;
1414
1415 if (PdoExt(PdoDevice)->EnumFlags & USBHUB_ENUM_FLAG_DEVICE_PRESENT)
1416 {
1417 PdoExt(PdoDevice)->EnumFlags &= ~USBHUB_ENUM_FLAG_GHOST_DEVICE;
1418 }
1419 }
1420 }
1421 }
1422
1423 Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
1424
1425 InitializeListHead(&GhostPdoList);
1426 PdoList = &HubExtension->PdoList;
1427
1428 while (!IsListEmpty(PdoList))
1429 {
1430 Entry = RemoveHeadList(PdoList);
1431
1432 PdoExtension = CONTAINING_RECORD(Entry,
1433 USBHUB_PORT_PDO_EXTENSION,
1434 PortLink);
1435
1436 PdoExtension->EnumFlags &= ~USBHUB_ENUM_FLAG_DEVICE_PRESENT;
1437
1438 if (PdoExtension->EnumFlags & USBHUB_ENUM_FLAG_GHOST_DEVICE)
1439 {
1440 InsertTailList(&GhostPdoList, &PdoExtension->PortLink);
1441 }
1442 }
1443
1444 KeReleaseSpinLock(&HubExtension->RelationsWorkerSpinLock, OldIrql);
1445
1446 while (!IsListEmpty(&GhostPdoList))
1447 {
1448 Entry = RemoveHeadList(&GhostPdoList);
1449
1450 PdoExtension = CONTAINING_RECORD(Entry,
1451 USBHUB_PORT_PDO_EXTENSION,
1452 PortLink);
1453
1454 IoDeleteDevice(PdoExtension->Common.SelfDevice);
1455 }
1456
1457 return USBH_PassIrp(HubExtension->LowerDevice, Irp);
1458}
1459
1460NTSTATUS
1461NTAPI
1462USBH_FdoStopDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
1463 IN PIRP Irp)
1464{
1465 DPRINT1("USBH_FdoStopDevice: UNIMPLEMENTED. FIXME\n");
1466 DbgBreakPoint();
1467 return STATUS_SUCCESS;
1468}
1469
1470NTSTATUS
1471NTAPI
1472USBH_FdoRemoveDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
1473 IN PIRP Irp)
1474{
1475 PUSB_HUB_DESCRIPTOR HubDescriptor;
1476 PUSBHUB_PORT_DATA PortData;
1477 USHORT NumPorts;
1478 USHORT ix;
1479 PDEVICE_OBJECT PortDevice;
1480 PUSBHUB_PORT_PDO_EXTENSION PortExtension;
1481 NTSTATUS Status;
1482
1483 DPRINT("USBH_FdoRemoveDevice: HubExtension - %p\n", HubExtension);
1484
1485 HubDescriptor = HubExtension->HubDescriptor;
1486
1487 if (HubDescriptor && HubExtension->PortData)
1488 {
1489 NumPorts = HubDescriptor->bNumberOfPorts;
1490
1491 for (ix = 0; ix < NumPorts; ++ix)
1492 {
1493 PortData = HubExtension->PortData + ix;
1494
1495 PortDevice = PortData->DeviceObject;
1496
1497 if (PortDevice)
1498 {
1499 PortData->PortStatus.AsUlong32 = 0;
1500 PortData->DeviceObject = NULL;
1501
1502 PortExtension = PortDevice->DeviceExtension;
1503 PortExtension->EnumFlags &= ~USBHUB_ENUM_FLAG_DEVICE_PRESENT;
1504
1505 USBH_PdoRemoveDevice(PortExtension, HubExtension);
1506 }
1507 }
1508 }
1509
1510 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED)
1511 {
1512 USBH_FdoCleanup(HubExtension);
1513 }
1514
1515 if (HubExtension->PortData)
1516 {
1517 ExFreePoolWithTag(HubExtension->PortData, USB_HUB_TAG);
1518 HubExtension->PortData = NULL;
1519 }
1520
1521 DPRINT1("USBH_FdoRemoveDevice: call IoWMIRegistrationControl UNIMPLEMENTED. FIXME\n");
1522
1523 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
1524
1525 IoDetachDevice(HubExtension->LowerDevice);
1526 IoDeleteDevice(HubExtension->Common.SelfDevice);
1527
1528 return Status;
1529}
1530
1531VOID
1532NTAPI
1533USBH_FdoSurpriseRemoveDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
1534 IN PIRP Irp)
1535{
1536 PUSBHUB_PORT_PDO_EXTENSION PortExtension;
1537 PUSBHUB_PORT_DATA PortData;
1538 ULONG NumberPorts;
1539 ULONG Port;
1540
1541 DPRINT("USBH_FdoSurpriseRemoveDevice: HubExtension - %p, Irp - %p\n",
1542 HubExtension,
1543 Irp);
1544
1545 if (!HubExtension->PortData ||
1546 !HubExtension->HubDescriptor)
1547 {
1548 return;
1549 }
1550
1551 PortData = HubExtension->PortData;
1552 NumberPorts = HubExtension->HubDescriptor->bNumberOfPorts;
1553
1554 for (Port = 0; Port < NumberPorts; Port++)
1555 {
1556 if (PortData[Port].DeviceObject)
1557 {
1558 PortExtension = PdoExt(PortData[Port].DeviceObject);
1559 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_DELETE_PENDING;
1560 PortExtension->EnumFlags &= ~USBHUB_ENUM_FLAG_DEVICE_PRESENT;
1561
1562 PortData[Port].DeviceObject = NULL;
1563 PortData[Port].ConnectionStatus = NoDeviceConnected;
1564 }
1565 }
1566}
1567
1568NTSTATUS
1569NTAPI
1570USBH_PdoQueryId(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
1571 IN PIRP Irp)
1572{
1573 ULONG IdType;
1574 WCHAR Buffer[200];
1575 PWCHAR EndBuffer;
1576 size_t Remaining = sizeof(Buffer);
1577 size_t Length;
1578 PWCHAR Id = NULL;
1579 NTSTATUS Status = STATUS_SUCCESS;
1580 PUSB_DEVICE_DESCRIPTOR DeviceDescriptor;
1581 PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
1582
1583 IdType = IoGetCurrentIrpStackLocation(Irp)->Parameters.QueryId.IdType;
1584 DeviceDescriptor = &PortExtension->DeviceDescriptor;
1585 InterfaceDescriptor = &PortExtension->InterfaceDescriptor;
1586
1587 RtlZeroMemory(Buffer, sizeof(Buffer));
1588
1589 switch (IdType)
1590 {
1591 case BusQueryDeviceID:
1592 DPRINT("USBH_PdoQueryId: BusQueryDeviceID\n");
1593
1594 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
1595 {
1596 DPRINT("USBH_PdoQueryId: USBHUB_PDO_FLAG_INIT_PORT_FAILED\n");
1597 RtlStringCbPrintfExW(Buffer,
1598 Remaining,
1599 NULL,
1600 &Remaining,
1601 0,
1602 L"USB\\Vid_0000&Pid_0000");
1603 }
1604 else
1605 {
1606 RtlStringCbPrintfExW(Buffer,
1607 Remaining,
1608 NULL,
1609 &Remaining,
1610 0,
1611 L"USB\\Vid_%04x&Pid_%04x",
1612 DeviceDescriptor->idVendor,
1613 DeviceDescriptor->idProduct);
1614 }
1615
1616 Length = sizeof(Buffer) - (Remaining - sizeof(UNICODE_NULL));
1617
1618 Id = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
1619
1620 if (!Id)
1621 {
1622 break;
1623 }
1624
1625 RtlCopyMemory(Id, Buffer, Length);
1626 DPRINT("USBH_PdoQueryId: BusQueryDeviceID - %S\n", Id);
1627 break;
1628
1629 case BusQueryHardwareIDs:
1630 DPRINT("USBH_PdoQueryId: BusQueryHardwareIDs\n");
1631
1632 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
1633 {
1634 DPRINT("USBH_PdoQueryId: USBHUB_PDO_FLAG_INIT_PORT_FAILED\n");
1635
1636 RtlStringCbPrintfExW(Buffer,
1637 Remaining,
1638 NULL,
1639 &Remaining,
1640 0,
1641 L"USB\\UNKNOWN");
1642 }
1643 else
1644 {
1645 RtlStringCbPrintfExW(Buffer,
1646 Remaining,
1647 &EndBuffer,
1648 &Remaining,
1649 0,
1650 L"USB\\Vid_%04x&Pid_%04x&Rev_%04x",
1651 DeviceDescriptor->idVendor,
1652 DeviceDescriptor->idProduct,
1653 DeviceDescriptor->bcdDevice);
1654
1655 EndBuffer++;
1656 Remaining -= sizeof(UNICODE_NULL);
1657
1658 RtlStringCbPrintfExW(EndBuffer,
1659 Remaining,
1660 NULL,
1661 &Remaining,
1662 0,
1663 L"USB\\Vid_%04x&Pid_%04x",
1664 DeviceDescriptor->idVendor,
1665 DeviceDescriptor->idProduct);
1666 }
1667
1668 Length = sizeof(Buffer) - (Remaining - 2 * sizeof(UNICODE_NULL));
1669
1670 Id = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
1671
1672 if (!Id)
1673 {
1674 break;
1675 }
1676
1677 RtlCopyMemory(Id, Buffer, Length);
1678
1679 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
1680 {
1681 DPRINT("USBH_PdoQueryId: BusQueryHardwareID - %S\n", Id);
1682 }
1683 else
1684 {
1685 USBHUB_DumpingIDs(Id);
1686 }
1687
1688 break;
1689
1690 case BusQueryCompatibleIDs:
1691 DPRINT("USBH_PdoQueryId: BusQueryCompatibleIDs\n");
1692
1693 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
1694 {
1695 DPRINT("USBH_PdoQueryId: USBHUB_PDO_FLAG_INIT_PORT_FAILED\n");
1696
1697 RtlStringCbPrintfExW(Buffer,
1698 Remaining,
1699 NULL,
1700 &Remaining,
1701 0,
1702 L"USB\\UNKNOWN");
1703 }
1704 else if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_MULTI_INTERFACE)
1705 {
1706 RtlStringCbPrintfExW(Buffer,
1707 Remaining,
1708 &EndBuffer,
1709 &Remaining,
1710 0,
1711 L"USB\\DevClass_%02x&SubClass_%02x&Prot_%02x",
1712 InterfaceDescriptor->bInterfaceClass,
1713 InterfaceDescriptor->bInterfaceSubClass,
1714 InterfaceDescriptor->bInterfaceProtocol);
1715
1716 EndBuffer++;
1717 Remaining -= sizeof(UNICODE_NULL);
1718
1719 RtlStringCbPrintfExW(EndBuffer,
1720 Remaining,
1721 &EndBuffer,
1722 &Remaining,
1723 0,
1724 L"USB\\DevClass_%02x&SubClass_%02x",
1725 InterfaceDescriptor->bInterfaceClass,
1726 InterfaceDescriptor->bInterfaceSubClass);
1727
1728 EndBuffer++;
1729 Remaining -= sizeof(UNICODE_NULL);
1730
1731 RtlStringCbPrintfExW(EndBuffer,
1732 Remaining,
1733 &EndBuffer,
1734 &Remaining,
1735 0,
1736 L"USB\\DevClass_%02x",
1737 InterfaceDescriptor->bInterfaceClass);
1738
1739 EndBuffer++;
1740 Remaining -= sizeof(UNICODE_NULL);
1741
1742 RtlStringCbPrintfExW(EndBuffer,
1743 Remaining,
1744 NULL,
1745 &Remaining,
1746 0,
1747 L"USB\\COMPOSITE");
1748 }
1749 else
1750 {
1751 RtlStringCbPrintfExW(Buffer,
1752 Remaining,
1753 &EndBuffer,
1754 &Remaining,
1755 0,
1756 L"USB\\Class_%02x&SubClass_%02x&Prot_%02x",
1757 InterfaceDescriptor->bInterfaceClass,
1758 InterfaceDescriptor->bInterfaceSubClass,
1759 InterfaceDescriptor->bInterfaceProtocol);
1760
1761 EndBuffer++;
1762 Remaining -= sizeof(UNICODE_NULL);
1763
1764 RtlStringCbPrintfExW(EndBuffer,
1765 Remaining,
1766 &EndBuffer,
1767 &Remaining,
1768 0,
1769 L"USB\\Class_%02x&SubClass_%02x",
1770 InterfaceDescriptor->bInterfaceClass,
1771 InterfaceDescriptor->bInterfaceSubClass);
1772
1773 EndBuffer++;
1774 Remaining -= sizeof(UNICODE_NULL);
1775
1776 RtlStringCbPrintfExW(EndBuffer,
1777 Remaining,
1778 NULL,
1779 &Remaining,
1780 0,
1781 L"USB\\Class_%02x",
1782 InterfaceDescriptor->bInterfaceClass);
1783 }
1784
1785 Length = sizeof(Buffer) - (Remaining - 2 * sizeof(UNICODE_NULL));
1786
1787 Id = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
1788
1789 if (!Id)
1790 {
1791 break;
1792 }
1793
1794 RtlCopyMemory(Id, Buffer, Length);
1795
1796 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
1797 {
1798 DPRINT("USBH_PdoQueryId: BusQueryCompatibleID - %S\n", Id);
1799 }
1800 else
1801 {
1802 USBHUB_DumpingIDs(Id);
1803 }
1804
1805 break;
1806
1807 case BusQueryInstanceID:
1808 DPRINT("USBH_PdoQueryId: BusQueryInstanceID\n");
1809
1810 if (PortExtension->SerialNumber)
1811 {
1812 Id = ExAllocatePoolWithTag(PagedPool,
1813 PortExtension->SN_DescriptorLength,
1814 USB_HUB_TAG);
1815
1816 if (Id)
1817 {
1818 RtlZeroMemory(Id, PortExtension->SN_DescriptorLength);
1819
1820 RtlCopyMemory(Id,
1821 PortExtension->SerialNumber,
1822 PortExtension->SN_DescriptorLength);
1823 }
1824 }
1825 else
1826 {
1827 Length = sizeof(PortExtension->InstanceID) +
1828 sizeof(UNICODE_NULL);
1829
1830 Id = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
1831
1832 if (Id)
1833 {
1834 RtlZeroMemory(Id, Length);
1835
1836 RtlCopyMemory(Id,
1837 PortExtension->InstanceID,
1838 sizeof(PortExtension->InstanceID));
1839 }
1840 }
1841
1842 DPRINT("USBH_PdoQueryId: BusQueryInstanceID - %S\n", Id);
1843 break;
1844
1845 default:
1846 DPRINT1("USBH_PdoQueryId: unknown query id type 0x%lx\n", IdType);
1847 return Irp->IoStatus.Status;
1848 }
1849
1850 Irp->IoStatus.Information = (ULONG_PTR)Id;
1851
1852 if (!Id)
1853 {
1854 Status = STATUS_INSUFFICIENT_RESOURCES;
1855 }
1856
1857 return Status;
1858}
1859
1860NTSTATUS
1861NTAPI
1862USBH_PdoQueryDeviceText(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
1863 IN PIRP Irp)
1864{
1865 PDEVICE_OBJECT DeviceObject;
1866 PIO_STACK_LOCATION IoStack;
1867 DEVICE_TEXT_TYPE DeviceTextType;
1868 USHORT LanguageId;
1869 USHORT DefaultId;
1870 PUSB_STRING_DESCRIPTOR Descriptor;
1871 PWCHAR DeviceText;
1872 UCHAR iProduct = 0;
1873 NTSTATUS Status;
1874 size_t NumSymbols;
1875 size_t Length;
1876
1877 DPRINT("USBH_PdoQueryDeviceText ... \n");
1878
1879 DeviceObject = PortExtension->Common.SelfDevice;
1880 IoStack = IoGetCurrentIrpStackLocation(Irp);
1881 DeviceTextType = IoStack->Parameters.QueryDeviceText.DeviceTextType;
1882
1883 if (DeviceTextType != DeviceTextDescription &&
1884 DeviceTextType != DeviceTextLocationInformation)
1885 {
1886 return Irp->IoStatus.Status;
1887 }
1888
1889 LanguageId = LANGIDFROMLCID(IoStack->Parameters.QueryDeviceText.LocaleId);
1890 DefaultId = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
1891
1892 if (!LanguageId)
1893 {
1894 LanguageId = DefaultId;
1895 }
1896
1897 iProduct = PortExtension->DeviceDescriptor.iProduct;
1898
1899 if (PortExtension->DeviceHandle && iProduct &&
1900 !PortExtension->IgnoringHwSerial &&
1901 !(PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED))
1902 {
1903 Descriptor = ExAllocatePoolWithTag(NonPagedPool,
1904 MAXIMUM_USB_STRING_LENGTH,
1905 USB_HUB_TAG);
1906
1907 if (Descriptor)
1908 {
1909 RtlZeroMemory(Descriptor, MAXIMUM_USB_STRING_LENGTH);
1910
1911 for (Status = USBH_CheckDeviceLanguage(DeviceObject, LanguageId);
1912 ;
1913 Status = USBH_CheckDeviceLanguage(DeviceObject, DefaultId))
1914 {
1915 if (NT_SUCCESS(Status))
1916 {
1917 Status = USBH_SyncGetStringDescriptor(DeviceObject,
1918 iProduct,
1919 LanguageId,
1920 Descriptor,
1921 MAXIMUM_USB_STRING_LENGTH,
1922 NULL,
1923 TRUE);
1924
1925 if (NT_SUCCESS(Status))
1926 {
1927 break;
1928 }
1929 }
1930
1931 if (LanguageId == DefaultId)
1932 {
1933 goto Exit;
1934 }
1935
1936 LanguageId = DefaultId;
1937 }
1938
1939 if (Descriptor->bLength <= sizeof(USB_COMMON_DESCRIPTOR))
1940 {
1941 Status = STATUS_UNSUCCESSFUL;
1942 }
1943
1944 if (NT_SUCCESS(Status))
1945 {
1946 Length = Descriptor->bLength -
1947 FIELD_OFFSET(USB_STRING_DESCRIPTOR, bString);
1948
1949 DeviceText = ExAllocatePoolWithTag(PagedPool,
1950 Length + sizeof(UNICODE_NULL),
1951 USB_HUB_TAG);
1952
1953 if (DeviceText)
1954 {
1955 RtlZeroMemory(DeviceText, Length + sizeof(UNICODE_NULL));
1956
1957 RtlCopyMemory(DeviceText, Descriptor->bString, Length);
1958
1959 Irp->IoStatus.Information = (ULONG_PTR)DeviceText;
1960
1961 DPRINT("USBH_PdoQueryDeviceText: Descriptor->bString - %S\n",
1962 DeviceText);
1963 }
1964 else
1965 {
1966 Status = STATUS_INSUFFICIENT_RESOURCES;
1967 }
1968 }
1969
1970 Exit:
1971
1972 ExFreePoolWithTag(Descriptor, USB_HUB_TAG);
1973
1974 if (NT_SUCCESS(Status))
1975 {
1976 return Status;
1977 }
1978 }
1979 else
1980 {
1981 Status = STATUS_INSUFFICIENT_RESOURCES;
1982 }
1983 }
1984 else
1985 {
1986 Status = STATUS_NOT_SUPPORTED;
1987 }
1988
1989 if (!GenericUSBDeviceString)
1990 {
1991 return Status;
1992 }
1993
1994 NumSymbols = wcslen(GenericUSBDeviceString);
1995 Length = (NumSymbols + 1) * sizeof(WCHAR);
1996
1997 DeviceText = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
1998
1999 if (!DeviceText)
2000 {
2001 return STATUS_INSUFFICIENT_RESOURCES;
2002 }
2003
2004 RtlZeroMemory(DeviceText, Length);
2005
2006 RtlCopyMemory(DeviceText,
2007 GenericUSBDeviceString,
2008 NumSymbols * sizeof(WCHAR));
2009
2010 Irp->IoStatus.Information = (ULONG_PTR)DeviceText;
2011
2012 return STATUS_SUCCESS;
2013}
2014
2015NTSTATUS
2016NTAPI
2017USBH_SymbolicLink(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
2018 IN const GUID * InterfaceClassGuid,
2019 IN BOOLEAN IsEnable)
2020{
2021 NTSTATUS Status = STATUS_SUCCESS;
2022 PVOID NameBuffer;
2023
2024 DPRINT("USBH_SymbolicLink ... \n");
2025
2026 if (IsEnable)
2027 {
2028 Status = IoRegisterDeviceInterface(PortExtension->Common.SelfDevice,
2029 InterfaceClassGuid,
2030 NULL,
2031 &PortExtension->SymbolicLinkName);
2032
2033 if (NT_SUCCESS(Status))
2034 {
2035 USBH_SetPdoRegistryParameter(PortExtension->Common.SelfDevice,
2036 L"SymbolicName",
2037 PortExtension->SymbolicLinkName.Buffer,
2038 PortExtension->SymbolicLinkName.Length,
2039 REG_SZ,
2040 PLUGPLAY_REGKEY_DEVICE);
2041
2042 Status = IoSetDeviceInterfaceState(&PortExtension->SymbolicLinkName,
2043 TRUE);
2044 }
2045 }
2046 else
2047 {
2048 NameBuffer = PortExtension->SymbolicLinkName.Buffer;
2049
2050 if (NameBuffer)
2051 {
2052 Status = IoSetDeviceInterfaceState(&PortExtension->SymbolicLinkName,
2053 FALSE);
2054
2055 ExFreePool(PortExtension->SymbolicLinkName.Buffer);
2056
2057 PortExtension->SymbolicLinkName.Buffer = NULL;
2058 }
2059 }
2060
2061 return Status;
2062}
2063
2064NTSTATUS
2065NTAPI
2066USBH_RestoreDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
2067 IN BOOLEAN IsKeepDeviceData)
2068{
2069 PUSBHUB_FDO_EXTENSION HubExtension;
2070 PUSBHUB_PORT_DATA PortData;
2071 NTSTATUS Status;
2072 ULONG ix;
2073
2074 DPRINT("USBH_RestoreDevice ... \n");
2075
2076 HubExtension = PortExtension->HubExtension;
2077
2078 if (!HubExtension)
2079 {
2080 Status = STATUS_UNSUCCESSFUL;
2081 return Status;
2082 }
2083
2084 ASSERT(PortExtension->PortNumber > 0);
2085 PortData = &HubExtension->PortData[PortExtension->PortNumber - 1];
2086
2087 if (PortExtension->Common.SelfDevice != PortData->DeviceObject)
2088 {
2089 Status = STATUS_UNSUCCESSFUL;
2090 return Status;
2091 }
2092
2093 Status = USBH_SyncGetPortStatus(HubExtension,
2094 PortExtension->PortNumber,
2095 &PortData->PortStatus,
2096 sizeof(USB_PORT_STATUS_AND_CHANGE));
2097
2098 if (NT_SUCCESS(Status))
2099 {
2100 for (ix = 0; ix < 3; ix++)
2101 {
2102 Status = USBH_ResetDevice((PUSBHUB_FDO_EXTENSION)HubExtension,
2103 PortExtension->PortNumber,
2104 IsKeepDeviceData,
2105 ix == 0);
2106
2107 if (NT_SUCCESS(Status) || Status == STATUS_NO_SUCH_DEVICE)
2108 {
2109 break;
2110 }
2111
2112 USBH_Wait(1000);
2113 }
2114 }
2115
2116 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_POWER_D3;
2117
2118 if (NT_SUCCESS(Status))
2119 {
2120 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_PORT_RESTORE_FAIL;
2121 }
2122 else
2123 {
2124 PortExtension->PortPdoFlags |= (USBHUB_PDO_FLAG_INIT_PORT_FAILED |
2125 USBHUB_PDO_FLAG_PORT_RESTORE_FAIL);
2126 }
2127
2128 return Status;
2129}
2130
2131NTSTATUS
2132NTAPI
2133USBH_PdoStartDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
2134 IN PIRP Irp)
2135{
2136 PUSBHUB_FDO_EXTENSION HubExtension;
2137 const GUID * Guid;
2138 NTSTATUS Status;
2139
2140 DPRINT("USBH_PdoStartDevice: PortExtension - %p\n", PortExtension);
2141
2142 if (!PortExtension->HubExtension &&
2143 PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_POWER_D3)
2144 {
2145 PortExtension->HubExtension = PortExtension->RootHubExtension;
2146 }
2147
2148 HubExtension = PortExtension->HubExtension;
2149
2150 if (HubExtension)
2151 {
2152 USBHUB_SetDeviceHandleData(HubExtension,
2153 PortExtension->Common.SelfDevice,
2154 PortExtension->DeviceHandle);
2155 }
2156
2157 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_HUB_DEVICE)
2158 {
2159 Guid = &GUID_DEVINTERFACE_USB_HUB;
2160 }
2161 else
2162 {
2163 Guid = &GUID_DEVINTERFACE_USB_DEVICE;
2164 }
2165
2166 Status = USBH_SymbolicLink(PortExtension, Guid, TRUE);
2167
2168 if (NT_SUCCESS(Status))
2169 {
2170 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_REG_DEV_INTERFACE;
2171 }
2172
2173 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_POWER_D3)
2174 {
2175 Status = USBH_RestoreDevice(PortExtension, 0);
2176 }
2177
2178 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_DEVICE_STARTED;
2179
2180 PortExtension->CurrentPowerState.DeviceState = PowerDeviceD0;
2181
2182 DPRINT1("USBH_PdoStartDevice: call IoWMIRegistrationControl UNIMPLEMENTED. FIXME\n");
2183
2184 return Status;
2185}
2186
2187NTSTATUS
2188NTAPI
2189USBH_PdoRemoveDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
2190 IN PUSBHUB_FDO_EXTENSION HubExtension)
2191{
2192 NTSTATUS Status = STATUS_SUCCESS;
2193 PDEVICE_OBJECT PortDevice;
2194 PUSBHUB_PORT_PDO_EXTENSION PortExt;
2195 PUSBHUB_PORT_DATA PortData;
2196 PIRP IdleNotificationIrp;
2197 PIRP WakeIrp;
2198 PVOID DeviceHandle;
2199 PDEVICE_OBJECT Pdo;
2200 PVOID SerialNumber;
2201 USHORT Port;
2202 KIRQL Irql;
2203
2204 DPRINT("USBH_PdoRemoveDevice ... \n");
2205
2206 PortDevice = PortExtension->Common.SelfDevice;
2207 PortExtension->HubExtension = NULL;
2208
2209 Port = PortExtension->PortNumber;
2210 ASSERT(Port > 0);
2211
2212 if (HubExtension &&
2213 HubExtension->CurrentPowerState.DeviceState != PowerDeviceD0 &&
2214 (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED) != 0)
2215 {
2216 USBH_HubSetD0(HubExtension);
2217 }
2218
2219 IoAcquireCancelSpinLock(&Irql);
2220 IdleNotificationIrp = PortExtension->IdleNotificationIrp;
2221
2222 if (IdleNotificationIrp)
2223 {
2224 PortExtension->IdleNotificationIrp = NULL;
2225 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_IDLE_NOTIFICATION;
2226
2227 if (IdleNotificationIrp->Cancel)
2228 {
2229 IdleNotificationIrp = NULL;
2230 }
2231
2232 if (IdleNotificationIrp)
2233 {
2234 IoSetCancelRoutine(IdleNotificationIrp, NULL);
2235 }
2236 }
2237
2238 WakeIrp = PortExtension->PdoWaitWakeIrp;
2239
2240 if (WakeIrp)
2241 {
2242 PortExtension->PdoWaitWakeIrp = NULL;
2243 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_WAIT_WAKE;
2244
2245 if (WakeIrp->Cancel || !IoSetCancelRoutine(WakeIrp, NULL))
2246 {
2247 WakeIrp = NULL;
2248
2249 ASSERT(HubExtension);
2250 if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
2251 {
2252 KeSetEvent(&HubExtension->PendingRequestEvent,
2253 EVENT_INCREMENT,
2254 FALSE);
2255 }
2256 }
2257 }
2258
2259 IoReleaseCancelSpinLock(Irql);
2260
2261 if (IdleNotificationIrp)
2262 {
2263 IdleNotificationIrp->IoStatus.Status = STATUS_CANCELLED;
2264 IoCompleteRequest(IdleNotificationIrp, IO_NO_INCREMENT);
2265 }
2266
2267 if (WakeIrp)
2268 {
2269 ASSERT(HubExtension);
2270 USBH_CompletePowerIrp(HubExtension, WakeIrp, STATUS_CANCELLED);
2271 }
2272
2273 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_POWER_D3;
2274
2275 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_REG_DEV_INTERFACE)
2276 {
2277 Status = USBH_SymbolicLink(PortExtension, NULL, FALSE);
2278
2279 if (NT_SUCCESS(Status))
2280 {
2281 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_REG_DEV_INTERFACE;
2282 }
2283 }
2284
2285 DeviceHandle = InterlockedExchangePointer(&PortExtension->DeviceHandle,
2286 NULL);
2287
2288 if (DeviceHandle)
2289 {
2290 ASSERT(HubExtension);
2291 Status = USBD_RemoveDeviceEx(HubExtension, DeviceHandle, 0);
2292
2293 if (HubExtension->PortData &&
2294 HubExtension->PortData[Port - 1].DeviceObject == PortDevice)
2295 {
2296 USBH_SyncDisablePort(HubExtension, Port);
2297 }
2298 }
2299
2300 if (NT_SUCCESS(Status))
2301 {
2302 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_DEVICE_STARTED;
2303
2304 if (HubExtension && HubExtension->PortData)
2305 {
2306 PortData = &HubExtension->PortData[Port - 1];
2307
2308 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_DELETE_PENDING)
2309 {
2310 Pdo = PortData->DeviceObject;
2311
2312 if (Pdo)
2313 {
2314 PortData->DeviceObject = NULL;
2315 PortData->ConnectionStatus = NoDeviceConnected;
2316
2317 if (PdoExt(Pdo)->EnumFlags & USBHUB_ENUM_FLAG_DEVICE_PRESENT)
2318 {
2319 PortExt = PdoExt(Pdo);
2320
2321 InsertTailList(&HubExtension->PdoList,
2322 &PortExt->PortLink);
2323 }
2324 }
2325 }
2326 }
2327
2328 if (!(PortExtension->EnumFlags & USBHUB_ENUM_FLAG_DEVICE_PRESENT) &&
2329 !(PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_NOT_CONNECTED))
2330 {
2331 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_NOT_CONNECTED;
2332
2333 SerialNumber = InterlockedExchangePointer((PVOID)&PortExtension->SerialNumber,
2334 NULL);
2335
2336 if (SerialNumber)
2337 {
2338 ExFreePoolWithTag(SerialNumber, USB_HUB_TAG);
2339 }
2340
2341 DPRINT1("USBH_PdoRemoveDevice: call IoWMIRegistrationControl UNIMPLEMENTED. FIXME\n");
2342
2343 if (HubExtension)
2344 USBHUB_FlushAllTransfers(HubExtension);
2345
2346 IoDeleteDevice(PortDevice);
2347 }
2348 }
2349
2350 if (HubExtension)
2351 {
2352 DPRINT("USBH_PdoRemoveDevice: call USBH_CheckIdleDeferred()\n");
2353 USBH_CheckIdleDeferred(HubExtension);
2354 }
2355
2356 return Status;
2357}
2358
2359NTSTATUS
2360NTAPI
2361USBH_PdoStopDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
2362 IN PIRP Irp)
2363{
2364 DPRINT1("USBH_PdoStopDevice: UNIMPLEMENTED. FIXME\n");
2365 DbgBreakPoint();
2366 return STATUS_SUCCESS;
2367}
2368
2369NTSTATUS
2370NTAPI
2371USBH_FdoPnP(IN PUSBHUB_FDO_EXTENSION HubExtension,
2372 IN PIRP Irp,
2373 IN UCHAR Minor)
2374{
2375 NTSTATUS Status;
2376 PIO_STACK_LOCATION IoStack;
2377 DEVICE_RELATION_TYPE RelationsType;
2378 BOOLEAN IsCheckIdle;
2379
2380 DPRINT_PNP("USBH_FdoPnP: HubExtension - %p, Irp - %p, Minor - %X\n",
2381 HubExtension,
2382 Irp,
2383 Minor);
2384
2385 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST &&
2386 (Minor == IRP_MN_REMOVE_DEVICE || Minor == IRP_MN_STOP_DEVICE))
2387 {
2388 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_SUSPENDED;
2389 }
2390
2391 KeWaitForSingleObject(&HubExtension->IdleSemaphore,
2392 Executive,
2393 KernelMode,
2394 FALSE,
2395 NULL);
2396
2397 DPRINT_PNP("USBH_FdoPnP: HubFlags - %lX\n", HubExtension->HubFlags);
2398
2399 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_GOING_IDLE)
2400 {
2401 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_SUSPENDED;
2402 }
2403
2404 IoStack = IoGetCurrentIrpStackLocation(Irp);
2405 RelationsType = IoStack->Parameters.QueryDeviceRelations.Type;
2406
2407 if ((HubExtension->CurrentPowerState.DeviceState == PowerDeviceD0) ||
2408 !(HubExtension->HubFlags & (USBHUB_FDO_FLAG_DEVICE_STOPPED | USBHUB_FDO_FLAG_DEVICE_STARTED)) ||
2409 (Minor == IRP_MN_QUERY_DEVICE_RELATIONS && RelationsType == TargetDeviceRelation))
2410 {
2411 IsCheckIdle = FALSE;
2412 }
2413 else
2414 {
2415 DPRINT_PNP("USBH_FdoPnP: IsCheckIdle - TRUE\n");
2416 IsCheckIdle = TRUE;
2417 USBH_HubSetD0(HubExtension);
2418 }
2419
2420 switch (Minor)
2421 {
2422 case IRP_MN_START_DEVICE:
2423 DPRINT_PNP("FDO IRP_MN_START_DEVICE\n");
2424 IsCheckIdle = FALSE;
2425 Irp->IoStatus.Status = STATUS_SUCCESS;
2426 Status = USBH_FdoStartDevice(HubExtension, Irp);
2427 break;
2428
2429 case IRP_MN_QUERY_REMOVE_DEVICE:
2430 DPRINT_PNP("FDO IRP_MN_QUERY_REMOVE_DEVICE\n");
2431 Irp->IoStatus.Status = STATUS_SUCCESS;
2432 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2433 break;
2434
2435 case IRP_MN_REMOVE_DEVICE:
2436 DPRINT_PNP("FDO IRP_MN_REMOVE_DEVICE\n");
2437 IsCheckIdle = FALSE;
2438 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_REMOVED;
2439 Irp->IoStatus.Status = STATUS_SUCCESS;
2440 Status = USBH_FdoRemoveDevice(HubExtension, Irp);
2441 break;
2442
2443 case IRP_MN_CANCEL_REMOVE_DEVICE:
2444 DPRINT_PNP("FDO IRP_MN_CANCEL_REMOVE_DEVICE\n");
2445 Irp->IoStatus.Status = STATUS_SUCCESS;
2446 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2447 break;
2448
2449 case IRP_MN_STOP_DEVICE:
2450 DPRINT_PNP("FDO IRP_MN_STOP_DEVICE\n");
2451 IsCheckIdle = FALSE;
2452 Irp->IoStatus.Status = STATUS_SUCCESS;
2453 Status = USBH_FdoStopDevice(HubExtension, Irp);
2454 break;
2455
2456 case IRP_MN_QUERY_STOP_DEVICE:
2457 DPRINT_PNP("FDO IRP_MN_QUERY_STOP_DEVICE\n");
2458 Irp->IoStatus.Status = STATUS_SUCCESS;
2459 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2460 break;
2461
2462 case IRP_MN_CANCEL_STOP_DEVICE:
2463 DPRINT_PNP("FDO IRP_MN_CANCEL_STOP_DEVICE\n");
2464 Irp->IoStatus.Status = STATUS_SUCCESS;
2465 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2466 break;
2467
2468 case IRP_MN_QUERY_DEVICE_RELATIONS:
2469 DPRINT_PNP("FDO IRP_MN_QUERY_DEVICE_RELATIONS\n");
2470
2471 if (RelationsType != BusRelations)
2472 {
2473 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2474 break;
2475 }
2476
2477 HubExtension->HubFlags |= USBHUB_FDO_FLAG_HUB_BUSY;
2478
2479 IsCheckIdle = TRUE;
2480 DPRINT_PNP("USBH_FdoPnP: IsCheckIdle - TRUE\n");
2481
2482 Status = USBH_FdoQueryBusRelations(HubExtension, Irp);
2483
2484 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_HUB_BUSY;
2485 break;
2486
2487 case IRP_MN_QUERY_INTERFACE:
2488 DPRINT_PNP("FDO IRP_MN_QUERY_INTERFACE\n");
2489 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2490 break;
2491
2492 case IRP_MN_QUERY_CAPABILITIES:
2493 DPRINT_PNP("FDO IRP_MN_QUERY_CAPABILITIES\n");
2494 IoCopyCurrentIrpStackLocationToNext(Irp);
2495
2496 IoSetCompletionRoutine(Irp,
2497 USBH_QueryCapsComplete,
2498 HubExtension,
2499 TRUE,
2500 FALSE,
2501 FALSE);
2502
2503 Status = IoCallDriver(HubExtension->LowerDevice, Irp);
2504 break;
2505
2506 case IRP_MN_QUERY_RESOURCES:
2507 DPRINT_PNP("FDO IRP_MN_QUERY_RESOURCES\n");
2508 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2509 break;
2510
2511 case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
2512 DPRINT_PNP("FDO IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
2513 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2514 break;
2515
2516 case IRP_MN_QUERY_DEVICE_TEXT:
2517 DPRINT_PNP("FDO IRP_MN_QUERY_DEVICE_TEXT\n");
2518 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2519 break;
2520
2521 case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
2522 DPRINT_PNP("FDO IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
2523 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2524 break;
2525
2526 case IRP_MN_READ_CONFIG:
2527 DPRINT_PNP("FDO IRP_MN_READ_CONFIG\n");
2528 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2529 break;
2530
2531 case IRP_MN_WRITE_CONFIG:
2532 DPRINT_PNP("FDO IRP_MN_WRITE_CONFIG\n");
2533 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2534 break;
2535
2536 case IRP_MN_EJECT:
2537 DPRINT_PNP("FDO IRP_MN_EJECT\n");
2538 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2539 break;
2540
2541 case IRP_MN_SET_LOCK:
2542 DPRINT_PNP("FDO IRP_MN_SET_LOCK\n");
2543 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2544 break;
2545
2546 case IRP_MN_QUERY_ID:
2547 DPRINT_PNP("FDO IRP_MN_QUERY_ID\n");
2548 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2549 break;
2550
2551 case IRP_MN_QUERY_PNP_DEVICE_STATE:
2552 DPRINT_PNP("FDO IRP_MN_QUERY_PNP_DEVICE_STATE\n");
2553
2554 if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED)
2555 {
2556 Irp->IoStatus.Information |= PNP_DEVICE_FAILED;
2557 }
2558
2559 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2560 break;
2561
2562 case IRP_MN_QUERY_BUS_INFORMATION:
2563 DPRINT_PNP("FDO IRP_MN_QUERY_BUS_INFORMATION\n");
2564 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2565 break;
2566
2567 case IRP_MN_DEVICE_USAGE_NOTIFICATION:
2568 DPRINT_PNP("FDO IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
2569 Irp->IoStatus.Status = STATUS_SUCCESS;
2570 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2571 break;
2572
2573 case IRP_MN_SURPRISE_REMOVAL:
2574 DPRINT_PNP("FDO IRP_MN_SURPRISE_REMOVAL\n");
2575 USBH_FdoSurpriseRemoveDevice(HubExtension, Irp);
2576 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2577 break;
2578
2579 default:
2580 DPRINT_PNP("FDO unknown IRP_MN_???\n");
2581 Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
2582 break;
2583 }
2584
2585 KeReleaseSemaphore(&HubExtension->IdleSemaphore,
2586 LOW_REALTIME_PRIORITY,
2587 1,
2588 FALSE);
2589
2590 if (IsCheckIdle)
2591 {
2592 DPRINT_PNP("USBH_FdoPnP: call USBH_CheckIdleDeferred()\n");
2593 USBH_CheckIdleDeferred(HubExtension);
2594 }
2595
2596 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_STATE_CHANGING;
2597
2598 return Status;
2599}
2600
2601NTSTATUS
2602NTAPI
2603USBH_PdoPnP(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
2604 IN PIRP Irp,
2605 IN UCHAR Minor,
2606 OUT BOOLEAN * IsCompleteIrp)
2607{
2608 NTSTATUS Status;
2609 PIO_STACK_LOCATION IoStack;
2610 PPNP_BUS_INFORMATION BusInfo;
2611 PDEVICE_CAPABILITIES DeviceCapabilities;
2612 USHORT Size;
2613 USHORT Version;
2614 PUSBHUB_FDO_EXTENSION HubExtension;
2615 PDEVICE_RELATIONS DeviceRelation;
2616
2617 DPRINT_PNP("USBH_PdoPnP: PortExtension - %p, Irp - %p, Minor - %X\n",
2618 PortExtension,
2619 Irp,
2620 Minor);
2621
2622 IoStack = IoGetCurrentIrpStackLocation(Irp);
2623
2624 *IsCompleteIrp = TRUE;
2625
2626 switch (Minor)
2627 {
2628 case IRP_MN_START_DEVICE:
2629 DPRINT_PNP("PDO IRP_MN_START_DEVICE\n");
2630 return USBH_PdoStartDevice(PortExtension, Irp);
2631
2632 case IRP_MN_QUERY_REMOVE_DEVICE:
2633 DPRINT_PNP("PDO IRP_MN_QUERY_REMOVE_DEVICE\n");
2634 return STATUS_SUCCESS;
2635
2636 case IRP_MN_REMOVE_DEVICE:
2637 DPRINT_PNP("PDO IRP_MN_REMOVE_DEVICE\n");
2638 return USBH_PdoRemoveDevice(PortExtension, PortExtension->HubExtension);
2639
2640 case IRP_MN_CANCEL_REMOVE_DEVICE:
2641 DPRINT_PNP("PDO IRP_MN_CANCEL_REMOVE_DEVICE\n");
2642 return STATUS_SUCCESS;
2643
2644 case IRP_MN_STOP_DEVICE:
2645 DPRINT_PNP("PDO IRP_MN_STOP_DEVICE\n");
2646 return USBH_PdoStopDevice(PortExtension, Irp);
2647
2648 case IRP_MN_QUERY_STOP_DEVICE:
2649 DPRINT_PNP("PDO IRP_MN_QUERY_STOP_DEVICE\n");
2650 return STATUS_SUCCESS;
2651
2652 case IRP_MN_CANCEL_STOP_DEVICE:
2653 DPRINT_PNP("PDO IRP_MN_CANCEL_STOP_DEVICE\n");
2654 return STATUS_SUCCESS;
2655
2656 case IRP_MN_QUERY_DEVICE_RELATIONS:
2657 DPRINT_PNP("PDO IRP_MN_QUERY_DEVICE_RELATIONS\n");
2658
2659 if (IoStack->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation)
2660 {
2661 return Irp->IoStatus.Status;
2662 }
2663
2664 DeviceRelation = ExAllocatePoolWithTag(PagedPool,
2665 sizeof(DEVICE_RELATIONS),
2666 USB_HUB_TAG);
2667
2668 if (DeviceRelation)
2669 {
2670 RtlZeroMemory(DeviceRelation, sizeof(DEVICE_RELATIONS));
2671
2672 DeviceRelation->Count = 1;
2673 DeviceRelation->Objects[0] = PortExtension->Common.SelfDevice;
2674
2675 ObReferenceObject(DeviceRelation->Objects[0]);
2676
2677 Status = STATUS_SUCCESS;
2678 }
2679 else
2680 {
2681 Status = STATUS_INSUFFICIENT_RESOURCES;
2682 }
2683
2684 Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
2685 break;
2686
2687 case IRP_MN_QUERY_INTERFACE:
2688 DPRINT_PNP("PDO IRP_MN_QUERY_INTERFACE\n");
2689
2690 *IsCompleteIrp = 0;
2691
2692 if (IsEqualGUIDAligned(IoStack->Parameters.QueryInterface.InterfaceType,
2693 &USB_BUS_INTERFACE_USBDI_GUID))
2694 {
2695 IoStack->Parameters.QueryInterface.InterfaceSpecificData = PortExtension->DeviceHandle;
2696 }
2697
2698 HubExtension = PortExtension->HubExtension;
2699
2700 if (!HubExtension)
2701 {
2702 HubExtension = PortExtension->RootHubExtension;
2703 }
2704
2705 Status = USBH_PassIrp(HubExtension->RootHubPdo, Irp);
2706 break;
2707
2708 case IRP_MN_QUERY_CAPABILITIES:
2709 DPRINT_PNP("PDO IRP_MN_QUERY_CAPABILITIES\n");
2710
2711 DeviceCapabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
2712
2713 Size = DeviceCapabilities->Size;
2714 Version = DeviceCapabilities->Version;
2715
2716 RtlCopyMemory(DeviceCapabilities,
2717 &PortExtension->Capabilities,
2718 sizeof(DEVICE_CAPABILITIES));
2719
2720 DeviceCapabilities->Size = Size;
2721 DeviceCapabilities->Version = Version;
2722
2723 /* All devices connected to a hub are removable */
2724 DeviceCapabilities->Removable = 1;
2725
2726 Status = STATUS_SUCCESS;
2727 break;
2728
2729 case IRP_MN_QUERY_RESOURCES:
2730 DPRINT_PNP("PDO IRP_MN_QUERY_RESOURCES\n");
2731 Status = Irp->IoStatus.Status;
2732 break;
2733
2734 case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
2735 DPRINT_PNP("PDO IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
2736 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_ENUMERATED;
2737
2738 /* FIXME HKEY_LOCAL_MACHINE\SYSTEM\ControlSetXXX\Enum\USB\
2739 Vid_????&Pid_????\????????????\Device Parameters\
2740 if (ExtPropDescSemaphore)
2741 */
2742
2743 Status = STATUS_SUCCESS;
2744 break;
2745
2746 case IRP_MN_QUERY_DEVICE_TEXT:
2747 DPRINT_PNP("PDO IRP_MN_QUERY_DEVICE_TEXT\n");
2748 return USBH_PdoQueryDeviceText(PortExtension, Irp);
2749
2750 case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
2751 DPRINT_PNP("PDO IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
2752 Status = Irp->IoStatus.Status;
2753 break;
2754
2755 case IRP_MN_READ_CONFIG:
2756 DPRINT_PNP("PDO IRP_MN_READ_CONFIG\n");
2757 DbgBreakPoint();
2758 Status = Irp->IoStatus.Status;
2759 break;
2760
2761 case IRP_MN_WRITE_CONFIG:
2762 DPRINT_PNP("PDO IRP_MN_WRITE_CONFIG\n");
2763 DbgBreakPoint();
2764 Status = Irp->IoStatus.Status;
2765 break;
2766
2767 case IRP_MN_EJECT:
2768 DPRINT_PNP("PDO IRP_MN_EJECT\n");
2769 DbgBreakPoint();
2770 Status = Irp->IoStatus.Status;
2771 break;
2772
2773 case IRP_MN_SET_LOCK:
2774 DPRINT_PNP("PDO IRP_MN_SET_LOCK\n");
2775 DbgBreakPoint();
2776 Status = Irp->IoStatus.Status;
2777 break;
2778
2779 case IRP_MN_QUERY_ID:
2780 DPRINT_PNP("PDO IRP_MN_QUERY_ID\n");
2781 return USBH_PdoQueryId(PortExtension, Irp);
2782
2783 case IRP_MN_QUERY_PNP_DEVICE_STATE:
2784 DPRINT_PNP("PDO IRP_MN_QUERY_PNP_DEVICE_STATE\n");
2785 if (PortExtension->PortPdoFlags & (USBHUB_PDO_FLAG_INSUFFICIENT_PWR |
2786 USBHUB_PDO_FLAG_OVERCURRENT_PORT |
2787 USBHUB_PDO_FLAG_PORT_RESTORE_FAIL |
2788 USBHUB_PDO_FLAG_INIT_PORT_FAILED))
2789 {
2790 Irp->IoStatus.Information |= PNP_DEVICE_FAILED;
2791 }
2792
2793 Status = STATUS_SUCCESS;
2794 break;
2795
2796 case IRP_MN_QUERY_BUS_INFORMATION:
2797 DPRINT_PNP("PDO IRP_MN_QUERY_BUS_INFORMATION\n");
2798
2799 BusInfo = ExAllocatePoolWithTag(PagedPool,
2800 sizeof(PNP_BUS_INFORMATION),
2801 USB_HUB_TAG);
2802
2803 if (!BusInfo)
2804 {
2805 return STATUS_INSUFFICIENT_RESOURCES;
2806 }
2807
2808 RtlZeroMemory(BusInfo, sizeof(PNP_BUS_INFORMATION));
2809
2810 RtlCopyMemory(&BusInfo->BusTypeGuid,
2811 &GUID_BUS_TYPE_USB,
2812 sizeof(BusInfo->BusTypeGuid));
2813
2814 BusInfo->LegacyBusType = PNPBus;
2815 BusInfo->BusNumber = 0;
2816
2817 Irp->IoStatus.Information = (ULONG_PTR)BusInfo;
2818 Status = STATUS_SUCCESS;
2819 break;
2820
2821 case IRP_MN_DEVICE_USAGE_NOTIFICATION:
2822 DPRINT_PNP("PDO IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
2823 DbgBreakPoint();
2824 Status = Irp->IoStatus.Status;
2825 break;
2826
2827 case IRP_MN_SURPRISE_REMOVAL:
2828 DPRINT_PNP("PDO IRP_MN_SURPRISE_REMOVAL\n");
2829 if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_REG_DEV_INTERFACE)
2830 {
2831 Status = USBH_SymbolicLink(PortExtension, NULL, FALSE);
2832
2833 if (NT_SUCCESS(Status))
2834 {
2835 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_REG_DEV_INTERFACE;
2836 }
2837 }
2838
2839 Status = STATUS_SUCCESS;
2840 break;
2841
2842 default:
2843 DPRINT_PNP("PDO unknown IRP_MN_???\n");
2844 Status = Irp->IoStatus.Status;
2845 break;
2846 }
2847
2848 return Status;
2849}
IoGetCurrentIrpStackLocation
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:152
Id
DWORD Id
Definition: CLayerUIPropPage.cpp:47
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
REG_SZ
#define REG_SZ
Definition: layer.c:22
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
InterlockedDecrement
#define InterlockedDecrement
Definition: armddk.h:52
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
DPRINT1
#define DPRINT1
Definition: precomp.h:8
IRP_MJ_PNP
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
Buffer
Definition: bufpool.h:45
Minor
ULONG Minor
Definition: classlib.cpp:99
IdType
_In_ BUS_QUERY_ID_TYPE IdType
Definition: classpnp.h:374
Irql
_Out_ PKIRQL Irql
Definition: csq.h:179
STATUS_NOT_IMPLEMENTED
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42
STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: d3dkmdt.h:48
dbg_uhub.h
DPRINT_PNP
#define DPRINT_PNP(...)
Definition: dbg_uhub.h:109
DPRINT_ENUM
#define DPRINT_ENUM(...)
Definition: dbg_uhub.h:111
Event
_Check_return_ _In_ DXGK_EVENT_TYPE _In_ ULONG Event
Definition: dispmprt.h:1287
DeviceDescriptor
_Check_return_ _In_ ULONG _Inout_ PDXGK_DEVICE_DESCRIPTOR DeviceDescriptor
Definition: dispmprt.h:1263
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
wcslen
_ACRTIMP size_t __cdecl wcslen(const wchar_t *)
Definition: wcs.c:2988
DefaultId
static const WCHAR DefaultId[]
Definition: register.c:82
L
#define L(x)
Definition: resources.c:13
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
PdoExtension
@ PdoExtension
Definition: precomp.h:61
USBHUB_DumpingIDs
VOID NTAPI USBHUB_DumpingIDs(IN PVOID Id)
Definition: debug.c:112
USBH_StartHubFdoDevice
NTSTATUS NTAPI USBH_StartHubFdoDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:645
USBHUB_GetBusInterface
NTSTATUS NTAPI USBHUB_GetBusInterface(IN PDEVICE_OBJECT DeviceObject, OUT PUSB_BUS_INTERFACE_HUB_V5 BusInterface)
Definition: pnp.c:85
USBH_RestoreDevice
NTSTATUS NTAPI USBH_RestoreDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN BOOLEAN IsKeepDeviceData)
Definition: pnp.c:2066
USBH_PdoPnP
NTSTATUS NTAPI USBH_PdoPnP(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp, IN UCHAR Minor, OUT BOOLEAN *IsCompleteIrp)
Definition: pnp.c:2603
USBH_QueryCapsComplete
NTSTATUS NTAPI USBH_QueryCapsComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: pnp.c:59
USBH_IrpCompletion
NTSTATUS NTAPI USBH_IrpCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: pnp.c:19
USBH_OpenConfiguration
NTSTATUS NTAPI USBH_OpenConfiguration(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: pnp.c:260
USBH_HubPnPIrpComplete
NTSTATUS NTAPI USBH_HubPnPIrpComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: pnp.c:34
USBH_PdoStopDevice
NTSTATUS NTAPI USBH_PdoStopDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: pnp.c:2361
USBH_PdoRemoveDevice
NTSTATUS NTAPI USBH_PdoRemoveDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: pnp.c:2189
USBH_QueryCapabilities
VOID NTAPI USBH_QueryCapabilities(IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_CAPABILITIES DeviceCapabilities)
Definition: pnp.c:205
USBHUB_GetBusInterfaceUSBDI
NTSTATUS NTAPI USBHUB_GetBusInterfaceUSBDI(IN PDEVICE_OBJECT DeviceObject, OUT PUSB_BUS_INTERFACE_USBDI_V2 BusInterfaceUSBDI)
Definition: pnp.c:145
USBH_FdoStartDevice
NTSTATUS NTAPI USBH_FdoStartDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:988
USBH_FdoCleanup
VOID NTAPI USBH_FdoCleanup(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: pnp.c:431
USBH_PdoStartDevice
NTSTATUS NTAPI USBH_PdoStartDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: pnp.c:2133
USBD_Initialize20Hub
NTSTATUS NTAPI USBD_Initialize20Hub(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: pnp.c:359
USBH_FdoRemoveDevice
NTSTATUS NTAPI USBH_FdoRemoveDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:1472
USBH_AbortInterruptPipe
NTSTATUS NTAPI USBH_AbortInterruptPipe(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: pnp.c:390
USBH_FdoQueryBusRelations
NTSTATUS NTAPI USBH_FdoQueryBusRelations(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:1027
USBH_PdoQueryDeviceText
NTSTATUS NTAPI USBH_PdoQueryDeviceText(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: pnp.c:1862
USBH_SymbolicLink
NTSTATUS NTAPI USBH_SymbolicLink(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN const GUID *InterfaceClassGuid, IN BOOLEAN IsEnable)
Definition: pnp.c:2017
USBH_FdoStopDevice
NTSTATUS NTAPI USBH_FdoStopDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:1462
USBH_PdoQueryId
NTSTATUS NTAPI USBH_PdoQueryId(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: pnp.c:1570
USBH_FdoPnP
NTSTATUS NTAPI USBH_FdoPnP(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp, IN UCHAR Minor)
Definition: pnp.c:2371
USBH_FdoSurpriseRemoveDevice
VOID NTAPI USBH_FdoSurpriseRemoveDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:1533
USBH_HubCancelWakeIrp
VOID NTAPI USBH_HubCancelWakeIrp(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: power.c:43
USBH_HubSetD0
NTSTATUS NTAPI USBH_HubSetD0(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: power.c:104
USBH_HubCompletePortWakeIrps
VOID NTAPI USBH_HubCompletePortWakeIrps(IN PUSBHUB_FDO_EXTENSION HubExtension, IN NTSTATUS NtStatus)
Definition: power.c:308
USBH_CompletePowerIrp
VOID NTAPI USBH_CompletePowerIrp(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp, IN NTSTATUS NtStatus)
Definition: power.c:18
InterlockedExchangePointer
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
IsListEmpty
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
KeWaitForSingleObject
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
PDEVICE_OBJECT
struct _DEVICE_OBJECT * PDEVICE_OBJECT
KeInitializeEvent
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
KeReleaseSpinLock
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
KeSetEvent
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
KeAcquireSpinLock
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
RemoveHeadList
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
NonPagedPool
#define NonPagedPool
Definition: env_spec_w32.h:307
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
KeDelayExecutionThread
#define KeDelayExecutionThread(mode, foo, t)
Definition: env_spec_w32.h:484
KeInitializeSpinLock
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
PagedPool
#define PagedPool
Definition: env_spec_w32.h:308
Status
Status
Definition: gdiplustypes.h:24
Port
CPPORT Port[4]
Definition: headless.c:38
Capabilities
_Must_inspect_result_ typedef _Out_ PHIDP_CAPS Capabilities
Definition: hidclass.h:103
USB_BUS_INTERFACE_HUB_V5
struct _USB_BUS_INTERFACE_HUB_V5 USB_BUS_INTERFACE_HUB_V5
USB_BUSIF_HUB_VERSION_5
#define USB_BUSIF_HUB_VERSION_5
Definition: hubbusif.h:426
PUSB_BUSIFFN_INITIALIZE_20HUB
USB_BUSIFFN_INITIALIZE_20HUB * PUSB_BUSIFFN_INITIALIZE_20HUB
Definition: hubbusif.h:241
TtCount
_In_ PUSB_DEVICE_HANDLE _In_ ULONG TtCount
Definition: hubbusif.h:240
Pdo
_In_ UCXUSBDEVICE _In_ PDEVICE_OBJECT Pdo
Definition: hubucx.h:280
LOW_REALTIME_PRIORITY
#define LOW_REALTIME_PRIORITY
IoMarkIrpPending
IoMarkIrpPending(Irp)
IoSetCancelRoutine
IoSetCancelRoutine(Irp, CancelRoutine)
IoSetCompletionRoutine
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
Irp
_In_ PIRP Irp
Definition: kse.h:79
Context
_In_ PIRP _In_ PIO_COMPLETION_ROUTINE _In_ PVOID Context
Definition: kse.h:81
DeviceType
DeviceType
Definition: mmdrv.h:42
ASSERT
#define ASSERT(a)
Definition: mode.c:44
ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
DeviceHandle
_In_ PIOMMU_DEVICE_PATH _In_ PIOMMU_SVM_CAPABILITIES _Out_ PVOID * DeviceHandle
Definition: haltypes.h:1894
DeviceCapabilities
_In_ PIOMMU_DEVICE_PATH _In_ PIOMMU_SVM_CAPABILITIES DeviceCapabilities
Definition: haltypes.h:1892
KernelMode
#define KernelMode
Definition: asm.h:38
Interval
DWORD Interval
Definition: netstat.c:28
UNICODE_NULL
#define UNICODE_NULL
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
NotificationEvent
@ NotificationEvent
Definition: ntdef.template.h:371
IRP_MN_SURPRISE_REMOVAL
#define IRP_MN_SURPRISE_REMOVAL
Definition: ntifs_ex.h:408
IoCopyCurrentIrpStackLocationToNext
#define IoCopyCurrentIrpStackLocationToNext(Irp)
Definition: ntifs_ex.h:413
IoDetachDevice
VOID NTAPI IoDetachDevice(IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:1306
IoDeleteDevice
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1261
IoRegisterDeviceInterface
NTSTATUS NTAPI IoRegisterDeviceInterface(IN PDEVICE_OBJECT PhysicalDeviceObject, IN CONST GUID *InterfaceClassGuid, IN PUNICODE_STRING ReferenceString OPTIONAL, OUT PUNICODE_STRING SymbolicLinkName)
Definition: deviface.c:1451
IoSetDeviceInterfaceState
NTSTATUS NTAPI IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName, IN BOOLEAN Enable)
Definition: deviface.c:1807
IoCompleteRequest
#define IoCompleteRequest
Definition: irp.c:1272
IoAllocateIrp
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:647
IoCancelIrp
BOOLEAN NTAPI IoCancelIrp(IN PIRP Irp)
Definition: irp.c:1133
IoCallDriver
#define IoCallDriver
Definition: irp.c:1257
IoFreeIrp
VOID NTAPI IoFreeIrp(IN PIRP Irp)
Definition: irp.c:1698
IoReleaseCancelSpinLock
VOID NTAPI IoReleaseCancelSpinLock(IN KIRQL Irql)
Definition: util.c:150
IoAcquireCancelSpinLock
VOID NTAPI IoAcquireCancelSpinLock(OUT PKIRQL Irql)
Definition: util.c:56
POWER_SYSTEM_MAXIMUM
#define POWER_SYSTEM_MAXIMUM
Definition: ntpoapi.h:45
PowerSystemWorking
@ PowerSystemWorking
Definition: ntpoapi.h:36
PowerDeviceD0
@ PowerDeviceD0
Definition: ntpoapi.h:49
DEVICE_POWER_STATE
enum _DEVICE_POWER_STATE DEVICE_POWER_STATE
STATUS_DELETE_PENDING
#define STATUS_DELETE_PENDING
Definition: ntstatus.h:416
RtlStringCbPrintfExW
NTSTRSAFEVAPI RtlStringCbPrintfExW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _Outptr_opt_result_bytebuffer_(*pcbRemaining) NTSTRSAFE_PWSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1335
WCHAR
short WCHAR
Definition: pedump.c:58
USHORT
unsigned short USHORT
Definition: pedump.c:61
IoInvalidateDeviceRelations
VOID NTAPI IoInvalidateDeviceRelations(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_RELATION_TYPE Type)
Definition: pnpmgr.c:1772
PNPBus
@ PNPBus
Definition: restypes.h:137
SerialNumber
ULONG SerialNumber
Definition: rxce.c:117
PINTERFACE
struct _INTERFACE * PINTERFACE
MAKELANGID
#define MAKELANGID(p, s)
Definition: nls.h:15
LANG_ENGLISH
#define LANG_ENGLISH
Definition: nls.h:52
LANGIDFROMLCID
#define LANGIDFROMLCID(l)
Definition: nls.h:18
SUBLANG_ENGLISH_US
#define SUBLANG_ENGLISH_US
Definition: nls.h:222
Entry
Entry
Definition: section.c:5216
KeInitializeSemaphore
VOID NTAPI KeInitializeSemaphore(IN PKSEMAPHORE Semaphore, IN LONG Count, IN LONG Limit)
Definition: semphobj.c:22
KeReleaseSemaphore
LONG NTAPI KeReleaseSemaphore(IN PKSEMAPHORE Semaphore, IN KPRIORITY Increment, IN LONG Adjustment, IN BOOLEAN Wait)
Definition: semphobj.c:54
STATUS_MORE_PROCESSING_REQUIRED
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
Next
STDMETHOD() Next(THIS_ ULONG celt, IAssociationElement *pElement, ULONG *pceltFetched) PURE
DPRINT
#define DPRINT
Definition: sndvol32.h:73
Exit
static void Exit(void)
Definition: sock.c:1330
_COMMON_DEVICE_EXTENSION::SelfDevice
PDEVICE_OBJECT SelfDevice
Definition: usbhub.h:144
_DEVICE_OBJECT
Definition: env_spec_w32.h:413
_DEVICE_OBJECT::Flags
ULONG Flags
Definition: env_spec_w32.h:419
_DEVICE_OBJECT::DeviceExtension
PVOID DeviceExtension
Definition: env_spec_w32.h:418
_DEVICE_RELATIONS
Definition: iotypes.h:2163
_DEVICE_RELATIONS::Count
ULONG Count
Definition: iotypes.h:2164
_DEVICE_RELATIONS::Objects
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2165
_IO_STACK_LOCATION
Definition: Bus_PDO_EvalMethod.c:95
_IO_STACK_LOCATION::QueryId
struct _IO_STACK_LOCATION::@5020::@5051 QueryId
_IO_STACK_LOCATION::MajorFunction
UCHAR MajorFunction
Definition: iotypes.h:3126
_IO_STACK_LOCATION::QueryDeviceRelations
struct _IO_STACK_LOCATION::@5020::@5045 QueryDeviceRelations
_IO_STACK_LOCATION::DeviceCapabilities
struct _IO_STACK_LOCATION::@5020::@5047 DeviceCapabilities
_IO_STACK_LOCATION::Parameters
union _IO_STACK_LOCATION::@1814 Parameters
_IO_STACK_LOCATION::QueryDeviceText
struct _IO_STACK_LOCATION::@5020::@5052 QueryDeviceText
_IO_STACK_LOCATION::MinorFunction
UCHAR MinorFunction
Definition: iotypes.h:3127
_IO_STACK_LOCATION::Length
ULONG Length
Definition: iotypes.h:3153
_IO_STACK_LOCATION::QueryInterface
struct _IO_STACK_LOCATION::@5020::@5046 QueryInterface
_IO_STATUS_BLOCK::Status
ULONG Status
Definition: env_spec_w32.h:871
_IRP
Definition: Bus_PDO_EvalMethod.c:107
_IRP::IoStatus
IO_STATUS_BLOCK IoStatus
Definition: Bus_PDO_EvalMethod.c:112
_KEVENT
Definition: ketypes.h:879
_LIST_ENTRY
Definition: typedefs.h:120
_PNP_BUS_INFORMATION
Definition: cmtypes.h:364
_PNP_BUS_INFORMATION::BusTypeGuid
GUID BusTypeGuid
Definition: cmtypes.h:365
_PNP_BUS_INFORMATION::LegacyBusType
INTERFACE_TYPE LegacyBusType
Definition: cmtypes.h:366
_PNP_BUS_INFORMATION::BusNumber
ULONG BusNumber
Definition: cmtypes.h:367
_URB_PIPE_REQUEST
Definition: usb.h:325
_URB
Definition: usb.h:557
_USBD_INTERFACE_INFORMATION::Pipes
USBD_PIPE_INFORMATION Pipes[1]
Definition: usb.h:297
_USBD_INTERFACE_LIST_ENTRY
Definition: usbdlib.h:7
_USBD_INTERFACE_LIST_ENTRY::Interface
PUSBD_INTERFACE_INFORMATION Interface
Definition: usbdlib.h:9
_USBD_INTERFACE_LIST_ENTRY::InterfaceDescriptor
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor
Definition: usbdlib.h:8
_USBD_PIPE_INFORMATION
Definition: usb.h:270
_USBHUB_FDO_EXTENSION
Definition: usbhub.h:147
_USBHUB_FDO_EXTENSION::PortData
PUSBHUB_PORT_DATA PortData
Definition: usbhub.h:167
_USBHUB_FDO_EXTENSION::Common
COMMON_DEVICE_EXTENSION Common
Definition: usbhub.h:148
_USBHUB_FDO_EXTENSION::LowerDeviceEvent
KEVENT LowerDeviceEvent
Definition: usbhub.h:153
_USBHUB_FDO_EXTENSION::RootHubPdo
PDEVICE_OBJECT RootHubPdo
Definition: usbhub.h:151
_USBHUB_FDO_EXTENSION::HubFlags
ULONG HubFlags
Definition: usbhub.h:154
_USBHUB_PORT_DATA
Definition: usbhub.h:117
_USBHUB_PORT_DATA::ConnectionStatus
USB_CONNECTION_STATUS ConnectionStatus
Definition: usbhub.h:120
_USBHUB_PORT_DATA::PortStatus
USB_PORT_STATUS_AND_CHANGE PortStatus
Definition: usbhub.h:118
_USBHUB_PORT_DATA::DeviceObject
PDEVICE_OBJECT DeviceObject
Definition: usbhub.h:119
_USBHUB_PORT_PDO_EXTENSION
Definition: usbhub.h:203
_USBHUB_PORT_PDO_EXTENSION::EnumFlags
ULONG EnumFlags
Definition: usbhub.h:206
_USBHUB_PORT_PDO_EXTENSION::PortLink
LIST_ENTRY PortLink
Definition: usbhub.h:227
_USBHUB_PORT_PDO_EXTENSION::PortNumber
USHORT PortNumber
Definition: usbhub.h:212
_USBHUB_PORT_PDO_EXTENSION::IdleNotificationIrp
PIRP IdleNotificationIrp
Definition: usbhub.h:221
_USBHUB_PORT_PDO_EXTENSION::DeviceHandle
PUSB_DEVICE_HANDLE DeviceHandle
Definition: usbhub.h:211
_USBHUB_PORT_PDO_EXTENSION::HubExtension
PUSBHUB_FDO_EXTENSION HubExtension
Definition: usbhub.h:209
_USBHUB_PORT_PDO_EXTENSION::PortPdoFlags
ULONG PortPdoFlags
Definition: usbhub.h:205
_USBHUB_PORT_PDO_EXTENSION::PdoWaitWakeIrp
PIRP PdoWaitWakeIrp
Definition: usbhub.h:232
_USB_BUS_INTERFACE_HUB_V5
Definition: hubbusif.h:535
_USB_BUS_INTERFACE_USBDI_V2
Definition: usbbusif.h:106
_USB_COMMON_DESCRIPTOR
Definition: usb100.h:165
_USB_DEVICE_DESCRIPTOR
Definition: usb100.h:110
_USB_HUB_DESCRIPTOR
Definition: usb100.h:170
_USB_HUB_DESCRIPTOR::bNumberOfPorts
UCHAR bNumberOfPorts
Definition: usb100.h:173
_USB_INTERFACE_DESCRIPTOR
Definition: usb100.h:147
_USB_INTERFACE_DESCRIPTOR::bInterfaceClass
UCHAR bInterfaceClass
Definition: usb100.h:153
_USB_STRING_DESCRIPTOR
Definition: usb100.h:159
ErrorExit
static VOID ErrorExit(LPTSTR lpszMessage)
Definition: telnetd.c:647
STATUS_PENDING
#define STATUS_PENDING
Definition: telnetd.h:14
MAXULONG
#define MAXULONG
Definition: typedefs.h:251
UCHAR
unsigned char UCHAR
Definition: typedefs.h:53
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
NTAPI
#define NTAPI
Definition: typedefs.h:36
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
IN
#define IN
Definition: typedefs.h:39
PWCHAR
uint16_t * PWCHAR
Definition: typedefs.h:56
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
ULONG
uint32_t ULONG
Definition: typedefs.h:59
OUT
#define OUT
Definition: typedefs.h:40
STATUS_NO_SUCH_DEVICE
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
STATUS_INVALID_DEVICE_STATE
#define STATUS_INVALID_DEVICE_STATE
Definition: udferr_usr.h:178
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
STATUS_CANCELLED
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
NT_ERROR
#define NT_ERROR(Status)
Definition: umtypes.h:106
_LARGE_INTEGER
Definition: typedefs.h:103
_USB_20_PORT_STATUS::CurrentConnectStatus
USHORT CurrentConnectStatus
Definition: usb200.h:134
_USB_PORT_STATUS_AND_CHANGE
Definition: usb200.h:238
_USB_PORT_STATUS_AND_CHANGE::AsUlong32
ULONG AsUlong32
Definition: usb200.h:239
_USB_PORT_STATUS_AND_CHANGE::PortStatus
USB_PORT_STATUS PortStatus
Definition: usb200.h:241
_USB_PORT_STATUS
Definition: usb200.h:222
_USB_PORT_STATUS::Usb20PortStatus
USB_20_PORT_STATUS Usb20PortStatus
Definition: usb200.h:224
MAXIMUM_USB_STRING_LENGTH
#define MAXIMUM_USB_STRING_LENGTH
Definition: usb100.h:43
USB_DEVICE_CLASS_HUB
#define USB_DEVICE_CLASS_HUB
Definition: usb100.h:99
Usb20Device
@ Usb20Device
Definition: usb200.h:38
USB_DEVICE_TYPE
enum _USB_DEVICE_TYPE USB_DEVICE_TYPE
URB_FUNCTION_ABORT_PIPE
#define URB_FUNCTION_ABORT_PIPE
Definition: usb.h:88
USB_BUSIF_USBDI_VERSION_2
#define USB_BUSIF_USBDI_VERSION_2
Definition: usbbusif.h:75
USB_BUS_INTERFACE_USBDI_V2
struct _USB_BUS_INTERFACE_USBDI_V2 USB_BUS_INTERFACE_USBDI_V2
USBD_CreateConfigurationRequestEx
PURB NTAPI USBD_CreateConfigurationRequestEx(PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, PUSBD_INTERFACE_LIST_ENTRY InterfaceList)
Definition: usbd.c:329
USBD_ParseConfigurationDescriptorEx
PUSB_INTERFACE_DESCRIPTOR NTAPI USBD_ParseConfigurationDescriptorEx(PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, PVOID StartPosition, LONG InterfaceNumber, LONG AlternateSetting, LONG InterfaceClass, LONG InterfaceSubClass, LONG InterfaceProtocol)
Definition: usbd.c:496
USBD_GetPdoRegistryParameter
ULONG NTAPI USBD_GetPdoRegistryParameter(PDEVICE_OBJECT PhysicalDeviceObject, PVOID Parameter, ULONG ParameterLength, PWCHAR KeyName, ULONG KeyNameLength)
Definition: usbd.c:620
InterfaceList
_In_ PUSBD_INTERFACE_LIST_ENTRY InterfaceList
Definition: usbdlib.h:208
Urb
_In_ PIO_STACK_LOCATION _In_ PURB Urb
Definition: usbdlib.h:294
USBH_SubmitStatusChangeTransfer
NTSTATUS NTAPI USBH_SubmitStatusChangeTransfer(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:2457
USBH_WriteFailReasonID
NTSTATUS NTAPI USBH_WriteFailReasonID(IN PDEVICE_OBJECT DeviceObject, IN ULONG FailReason)
Definition: usbhub.c:153
GenericUSBDeviceString
PWSTR GenericUSBDeviceString
Definition: usbhub.c:19
USBHUB_SetDeviceHandleData
VOID NTAPI USBHUB_SetDeviceHandleData(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PDEVICE_OBJECT UsbDevicePdo, IN PVOID DeviceHandle)
Definition: usbhub.c:2616
USBH_SyncGetHubDescriptor
NTSTATUS NTAPI USBH_SyncGetHubDescriptor(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:1048
USBD_RemoveDeviceEx
NTSTATUS NTAPI USBD_RemoveDeviceEx(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE DeviceHandle, IN ULONG Flags)
Definition: usbhub.c:2553
USBH_CompleteIrp
VOID NTAPI USBH_CompleteIrp(IN PIRP Irp, IN NTSTATUS CompleteStatus)
Definition: usbhub.c:63
USBD_UnRegisterRootHubCallBack
NTSTATUS NTAPI USBD_UnRegisterRootHubCallBack(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:3023
USBH_CheckDeviceLanguage
NTSTATUS NTAPI USBH_CheckDeviceLanguage(IN PDEVICE_OBJECT DeviceObject, IN USHORT LanguageId)
Definition: usbhub.c:4257
USBH_GetDeviceDescriptor
NTSTATUS NTAPI USBH_GetDeviceDescriptor(IN PDEVICE_OBJECT DeviceObject, IN PUSB_DEVICE_DESCRIPTOR HubDeviceDescriptor)
Definition: usbhub.c:877
USBH_SyncGetRootHubPdo
NTSTATUS NTAPI USBH_SyncGetRootHubPdo(IN PDEVICE_OBJECT DeviceObject, IN OUT PDEVICE_OBJECT *OutPdo1, IN OUT PDEVICE_OBJECT *OutPdo2)
Definition: usbhub.c:728
USBH_Wait
NTSTATUS NTAPI USBH_Wait(IN ULONG Milliseconds)
Definition: usbhub.c:23
USBH_CheckIdleDeferred
VOID NTAPI USBH_CheckIdleDeferred(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:3972
USBH_SyncGetStringDescriptor
NTSTATUS NTAPI USBH_SyncGetStringDescriptor(IN PDEVICE_OBJECT DeviceObject, IN UCHAR Index, IN USHORT LanguageId, IN PUSB_STRING_DESCRIPTOR Descriptor, IN ULONG NumberOfBytes, IN PULONG OutLength, IN BOOLEAN IsValidateLength)
Definition: usbhub.c:1248
PdoExt
PUSBHUB_PORT_PDO_EXTENSION NTAPI PdoExt(IN PDEVICE_OBJECT DeviceObject)
Definition: usbhub.c:133
USBH_HubCancelIdleIrp
VOID NTAPI USBH_HubCancelIdleIrp(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP IdleIrp)
Definition: usbhub.c:3221
USBH_SyncGetPortStatus
NTSTATUS NTAPI USBH_SyncGetPortStatus(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN PUSB_PORT_STATUS_AND_CHANGE PortStatus, IN ULONG Length)
Definition: usbhub.c:1414
USBH_SyncGetDeviceHandle
PUSB_DEVICE_HANDLE NTAPI USBH_SyncGetDeviceHandle(IN PDEVICE_OBJECT DeviceObject)
Definition: usbhub.c:832
USBHUB_FlushAllTransfers
VOID NTAPI USBHUB_FlushAllTransfers(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:2638
USBH_GetConfigurationDescriptor
NTSTATUS NTAPI USBH_GetConfigurationDescriptor(IN PDEVICE_OBJECT DeviceObject, IN PUSB_CONFIGURATION_DESCRIPTOR *OutDescriptor)
Definition: usbhub.c:974
USBD_RegisterRootHubCallBack
NTSTATUS NTAPI USBD_RegisterRootHubCallBack(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:3001
USBH_CreateDevice
NTSTATUS NTAPI USBH_CreateDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN USB_PORT_STATUS UsbPortStatus, IN ULONG IsWait)
Definition: usbhub.c:4394
USBH_SyncDisablePort
NTSTATUS NTAPI USBH_SyncDisablePort(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port)
Definition: usbhub.c:1553
USBH_ResetDevice
NTSTATUS NTAPI USBH_ResetDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN BOOLEAN IsKeepDeviceData, IN BOOLEAN IsWait)
Definition: usbhub.c:4630
USBH_GetDeviceType
NTSTATUS NTAPI USBH_GetDeviceType(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE DeviceHandle, OUT USB_DEVICE_TYPE *OutDeviceType)
Definition: usbhub.c:608
USBH_SyncResetPort
NTSTATUS NTAPI USBH_SyncResetPort(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port)
Definition: usbhub.c:471
USBH_SyncGetHubCount
NTSTATUS NTAPI USBH_SyncGetHubCount(IN PDEVICE_OBJECT DeviceObject, IN OUT PULONG OutHubCount)
Definition: usbhub.c:781
USBH_SetPdoRegistryParameter
NTSTATUS NTAPI USBH_SetPdoRegistryParameter(IN PDEVICE_OBJECT DeviceObject, IN PCWSTR ValueName, IN PVOID Data, IN ULONG DataSize, IN ULONG Type, IN ULONG DevInstKeyType)
Definition: usbhub.c:213
USBH_FdoSyncSubmitUrb
NTSTATUS NTAPI USBH_FdoSyncSubmitUrb(IN PDEVICE_OBJECT FdoDevice, IN PURB Urb)
Definition: usbhub.c:355
USBH_SyncPowerOnPorts
NTSTATUS NTAPI USBH_SyncPowerOnPorts(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:1522
USBH_PassIrp
NTSTATUS NTAPI USBH_PassIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: usbhub.c:79
USBH_HubIsBusPowered
BOOLEAN NTAPI USBH_HubIsBusPowered(IN PDEVICE_OBJECT DeviceObject, IN PUSB_CONFIGURATION_DESCRIPTOR HubConfigDescriptor)
Definition: usbhub.c:1589
USBH_SyncClearPortStatus
NTSTATUS NTAPI USBH_SyncClearPortStatus(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN USHORT RequestValue)
Definition: usbhub.c:1442
USBHUB_FDO_FLAG_DEVICE_STARTED
#define USBHUB_FDO_FLAG_DEVICE_STARTED
Definition: usbhub.h:33
USBHUB_FDO_FLAG_MULTIPLE_TTS
#define USBHUB_FDO_FLAG_MULTIPLE_TTS
Definition: usbhub.h:50
USBHUB_PDO_FLAG_DEVICE_STARTED
#define USBHUB_PDO_FLAG_DEVICE_STARTED
Definition: usbhub.h:70
USBHUB_FDO_FLAG_DEVICE_STOPPING
#define USBHUB_FDO_FLAG_DEVICE_STOPPING
Definition: usbhub.h:34
USBHUB_PDO_FLAG_OVERCURRENT_PORT
#define USBHUB_PDO_FLAG_OVERCURRENT_PORT
Definition: usbhub.h:75
USBHUB_FDO_FLAG_DEVICE_SUSPENDED
#define USBHUB_FDO_FLAG_DEVICE_SUSPENDED
Definition: usbhub.h:58
USBHUB_FDO_FLAG_USB20_HUB
#define USBHUB_FDO_FLAG_USB20_HUB
Definition: usbhub.h:47
USBHUB_PDO_FLAG_HS_USB1_DUALMODE
#define USBHUB_PDO_FLAG_HS_USB1_DUALMODE
Definition: usbhub.h:71
USBHUB_FDO_FLAG_WITEM_INIT
#define USBHUB_FDO_FLAG_WITEM_INIT
Definition: usbhub.h:59
USBHUB_FDO_FLAG_ESD_RECOVERING
#define USBHUB_FDO_FLAG_ESD_RECOVERING
Definition: usbhub.h:41
USBHUB_PDO_FLAG_INSUFFICIENT_PWR
#define USBHUB_PDO_FLAG_INSUFFICIENT_PWR
Definition: usbhub.h:77
USBHUB_PDO_FLAG_PORT_HIGH_SPEED
#define USBHUB_PDO_FLAG_PORT_HIGH_SPEED
Definition: usbhub.h:81
USBHUB_PDO_FLAG_PORT_LOW_SPEED
#define USBHUB_PDO_FLAG_PORT_LOW_SPEED
Definition: usbhub.h:64
USBHUB_ENUM_FLAG_DEVICE_PRESENT
#define USBHUB_ENUM_FLAG_DEVICE_PRESENT
Definition: usbhub.h:84
USBHUB_FAIL_NESTED_TOO_DEEPLY
#define USBHUB_FAIL_NESTED_TOO_DEEPLY
Definition: usbhub.h:112
USB_HUB_TAG
#define USB_HUB_TAG
Definition: usbhub.h:26
USBHUB_PDO_FLAG_HUB_DEVICE
#define USBHUB_PDO_FLAG_HUB_DEVICE
Definition: usbhub.h:61
USBHUB_FEATURE_C_PORT_CONNECTION
#define USBHUB_FEATURE_C_PORT_CONNECTION
Definition: usbhub.h:98
USBHUB_FDO_FLAG_GOING_IDLE
#define USBHUB_FDO_FLAG_GOING_IDLE
Definition: usbhub.h:57
USBHUB_FDO_FLAG_REMOTE_WAKEUP
#define USBHUB_FDO_FLAG_REMOTE_WAKEUP
Definition: usbhub.h:36
USBHUB_FDO_FLAG_DEVICE_REMOVED
#define USBHUB_FDO_FLAG_DEVICE_REMOVED
Definition: usbhub.h:46
USBHUB_FDO_FLAG_DO_ENUMERATION
#define USBHUB_FDO_FLAG_DO_ENUMERATION
Definition: usbhub.h:52
USBHUB_FDO_FLAG_DEVICE_FAILED
#define USBHUB_FDO_FLAG_DEVICE_FAILED
Definition: usbhub.h:35
USBHUB_PDO_FLAG_MULTI_INTERFACE
#define USBHUB_PDO_FLAG_MULTI_INTERFACE
Definition: usbhub.h:62
USBHUB_FDO_FLAG_HUB_BUSY
#define USBHUB_FDO_FLAG_HUB_BUSY
Definition: usbhub.h:38
USBHUB_PDO_FLAG_PORT_RESTORE_FAIL
#define USBHUB_PDO_FLAG_PORT_RESTORE_FAIL
Definition: usbhub.h:73
USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST
#define USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST
Definition: usbhub.h:44
USBHUB_PDO_FLAG_ENUMERATED
#define USBHUB_PDO_FLAG_ENUMERATED
Definition: usbhub.h:82
USBHUB_PDO_FLAG_POWER_D3
#define USBHUB_PDO_FLAG_POWER_D3
Definition: usbhub.h:69
USBHUB_ENUM_FLAG_GHOST_DEVICE
#define USBHUB_ENUM_FLAG_GHOST_DEVICE
Definition: usbhub.h:85
USBHUB_PDO_FLAG_NOT_CONNECTED
#define USBHUB_PDO_FLAG_NOT_CONNECTED
Definition: usbhub.h:67
USBHUB_PDO_FLAG_REG_DEV_INTERFACE
#define USBHUB_PDO_FLAG_REG_DEV_INTERFACE
Definition: usbhub.h:72
USBHUB_FAIL_NO_FAIL
#define USBHUB_FAIL_NO_FAIL
Definition: usbhub.h:111
USBHUB_MAX_CASCADE_LEVELS
#define USBHUB_MAX_CASCADE_LEVELS
Definition: usbhub.h:106
USBHUB_FDO_FLAG_DEVICE_STOPPED
#define USBHUB_FDO_FLAG_DEVICE_STOPPED
Definition: usbhub.h:37
USBHUB_PDO_FLAG_INIT_PORT_FAILED
#define USBHUB_PDO_FLAG_INIT_PORT_FAILED
Definition: usbhub.h:63
USBHUB_PDO_FLAG_DELETE_PENDING
#define USBHUB_PDO_FLAG_DELETE_PENDING
Definition: usbhub.h:68
DeviceFailedEnumeration
@ DeviceFailedEnumeration
Definition: usbioctl.h:280
DeviceConnected
@ DeviceConnected
Definition: usbioctl.h:279
NoDeviceConnected
@ NoDeviceConnected
Definition: usbioctl.h:278
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2061
Size
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4539
Version
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469
Guid
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:762
Descriptor
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342
InterfaceDescriptor
_In_ WDFUSBINTERFACE _In_ UCHAR _Out_ PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor
Definition: wdfusb.h:2334
IsEqualGUIDAligned
#define IsEqualGUIDAligned(guid1, guid2)
Definition: wdm.template.h:235
DbgBreakPoint
NTSYSAPI void WINAPI DbgBreakPoint(void)
DeviceCapabilities
#define DeviceCapabilities
Definition: wingdi.h:4895
IoGetNextIrpStackLocation
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2702
InterfaceClassGuid
_In_ CONST GUID * InterfaceClassGuid
Definition: iofuncs.h:1136
PLUGPLAY_REGKEY_DEVICE
#define PLUGPLAY_REGKEY_DEVICE
Definition: iofuncs.h:2793
IRP_MN_CANCEL_STOP_DEVICE
#define IRP_MN_CANCEL_STOP_DEVICE
DEVICE_CAPABILITIES
DEVICE_CAPABILITIES
Definition: iotypes.h:965
BusRelations
@ BusRelations
Definition: iotypes.h:2154
TargetDeviceRelation
@ TargetDeviceRelation
Definition: iotypes.h:2158
STATUS_CONTINUE_COMPLETION
#define STATUS_CONTINUE_COMPLETION
IRP_MN_QUERY_PNP_DEVICE_STATE
#define IRP_MN_QUERY_PNP_DEVICE_STATE
IRP_MN_EJECT
#define IRP_MN_EJECT
EVENT_INCREMENT
#define EVENT_INCREMENT
Definition: iotypes.h:597
IO_NO_INCREMENT
#define IO_NO_INCREMENT
Definition: iotypes.h:598
IRP_MN_QUERY_INTERFACE
#define IRP_MN_QUERY_INTERFACE
IRP_MN_START_DEVICE
#define IRP_MN_START_DEVICE
PNP_DEVICE_FAILED
#define PNP_DEVICE_FAILED
Definition: iotypes.h:1003
IRP_MN_DEVICE_USAGE_NOTIFICATION
#define IRP_MN_DEVICE_USAGE_NOTIFICATION
IRP_MN_READ_CONFIG
#define IRP_MN_READ_CONFIG
IRP_MN_WRITE_CONFIG
#define IRP_MN_WRITE_CONFIG
IRP_MN_QUERY_RESOURCE_REQUIREMENTS
#define IRP_MN_QUERY_RESOURCE_REQUIREMENTS
IRP_MN_QUERY_ID
#define IRP_MN_QUERY_ID
IRP_MN_REMOVE_DEVICE
#define IRP_MN_REMOVE_DEVICE
IRP_MN_FILTER_RESOURCE_REQUIREMENTS
#define IRP_MN_FILTER_RESOURCE_REQUIREMENTS
IRP_MN_QUERY_DEVICE_RELATIONS
#define IRP_MN_QUERY_DEVICE_RELATIONS
DO_POWER_PAGABLE
#define DO_POWER_PAGABLE
IRP_MN_QUERY_STOP_DEVICE
#define IRP_MN_QUERY_STOP_DEVICE
IRP_MN_QUERY_DEVICE_TEXT
#define IRP_MN_QUERY_DEVICE_TEXT
IRP_MN_QUERY_CAPABILITIES
#define IRP_MN_QUERY_CAPABILITIES
IRP_MN_QUERY_RESOURCES
#define IRP_MN_QUERY_RESOURCES
PDEVICE_CAPABILITIES
* PDEVICE_CAPABILITIES
Definition: iotypes.h:965
IRP_MN_CANCEL_REMOVE_DEVICE
#define IRP_MN_CANCEL_REMOVE_DEVICE
IRP_MN_STOP_DEVICE
#define IRP_MN_STOP_DEVICE
IRP_MN_SET_LOCK
#define IRP_MN_SET_LOCK
DeviceTextLocationInformation
@ DeviceTextLocationInformation
Definition: iotypes.h:2961
DeviceTextDescription
@ DeviceTextDescription
Definition: iotypes.h:2960
DEVICE_TEXT_TYPE
enum _DEVICE_TEXT_TYPE DEVICE_TEXT_TYPE
BusQueryCompatibleIDs
@ BusQueryCompatibleIDs
Definition: iotypes.h:2953
BusQueryInstanceID
@ BusQueryInstanceID
Definition: iotypes.h:2954
BusQueryDeviceID
@ BusQueryDeviceID
Definition: iotypes.h:2951
BusQueryHardwareIDs
@ BusQueryHardwareIDs
Definition: iotypes.h:2952
DEVICE_RELATION_TYPE
enum _DEVICE_RELATION_TYPE DEVICE_RELATION_TYPE
IRP_MN_QUERY_BUS_INFORMATION
#define IRP_MN_QUERY_BUS_INFORMATION
IRP_MN_QUERY_REMOVE_DEVICE
#define IRP_MN_QUERY_REMOVE_DEVICE
OldIrql
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
Suspended
@ Suspended
Definition: ketypes.h:472
Executive
@ Executive
Definition: ketypes.h:467
ObDereferenceObject
#define ObDereferenceObject
Definition: obfuncs.h:203
ObReferenceObject
#define ObReferenceObject
Definition: obfuncs.h:204