xref: /reactos/drivers/usb/usbhub/power.c (revision 682f85ad) 
1 /*
2  * PROJECT:     ReactOS USB Hub Driver
3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4  * PURPOSE:     USBHub power handling 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_POWER
14 #include "dbg_uhub.h"
15 
16 VOID
17 NTAPI
18 USBH_CompletePowerIrp(IN PUSBHUB_FDO_EXTENSION HubExtension,
19                       IN PIRP Irp,
20                       IN NTSTATUS NtStatus)
21 {
22     DPRINT("USBH_CompletePowerIrp: HubExtension - %p, Irp - %p, NtStatus - %lX\n",
23            HubExtension,
24            Irp,
25            NtStatus);
26 
27     Irp->IoStatus.Status = NtStatus;
28 
29     PoStartNextPowerIrp(Irp);
30 
31     if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
32     {
33         KeSetEvent(&HubExtension->PendingRequestEvent,
34                    EVENT_INCREMENT,
35                    FALSE);
36     }
37 
38     IoCompleteRequest(Irp, IO_NO_INCREMENT);
39 }
40 
41 VOID
42 NTAPI
43 USBH_HubCancelWakeIrp(IN PUSBHUB_FDO_EXTENSION HubExtension,
44                       IN PIRP Irp)
45 {
46     DPRINT("USBH_HubCancelWakeIrp: HubExtension - %p, Irp - %p\n",
47            HubExtension,
48            Irp);
49 
50     IoCancelIrp(Irp);
51 
52     if (InterlockedExchange((PLONG)&HubExtension->FdoWaitWakeLock, 1))
53     {
54         PoStartNextPowerIrp(Irp);
55         Irp->IoStatus.Status = STATUS_CANCELLED;
56         IoCompleteRequest(Irp, IO_NO_INCREMENT);
57     }
58 }
59 
60 VOID
61 NTAPI
62 USBH_HubESDRecoverySetD3Completion(IN PDEVICE_OBJECT DeviceObject,
63                                    IN UCHAR MinorFunction,
64                                    IN POWER_STATE PowerState,
65                                    IN PVOID Context,
66                                    IN PIO_STATUS_BLOCK IoStatus)
67 {
68     DPRINT("USBH_HubESDRecoverySetD3Completion ... \n");
69 
70     KeSetEvent((PRKEVENT)Context,
71                EVENT_INCREMENT,
72                FALSE);
73 }
74 
75 NTSTATUS
76 NTAPI
77 USBH_HubSetD0(IN PUSBHUB_FDO_EXTENSION HubExtension)
78 {
79     PUSBHUB_FDO_EXTENSION RootHubDevExt;
80     NTSTATUS Status;
81     KEVENT Event;
82     POWER_STATE PowerState;
83 
84     DPRINT("USBH_HubSetD0: HubExtension - %p\n", HubExtension);
85 
86     RootHubDevExt = USBH_GetRootHubExtension(HubExtension);
87 
88     if (RootHubDevExt->SystemPowerState.SystemState != PowerSystemWorking)
89     {
90         Status = STATUS_INVALID_DEVICE_STATE;
91         return Status;
92     }
93 
94     if (HubExtension->HubFlags & USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST)
95     {
96         DPRINT("USBH_HubSetD0: HubFlags - %lX\n", HubExtension->HubFlags);
97 
98         KeWaitForSingleObject(&HubExtension->IdleEvent,
99                               Suspended,
100                               KernelMode,
101                               FALSE,
102                               NULL);
103     }
104 
105     KeInitializeEvent(&Event, NotificationEvent, FALSE);
106 
107     PowerState.DeviceState = PowerDeviceD0;
108 
109     Status = PoRequestPowerIrp(HubExtension->LowerPDO,
110                                IRP_MN_SET_POWER,
111                                PowerState,
112                                USBH_HubESDRecoverySetD3Completion,
113                                &Event,
114                                NULL);
115 
116     if (Status == STATUS_PENDING)
117     {
118        Status = KeWaitForSingleObject(&Event,
119                                       Suspended,
120                                       KernelMode,
121                                       FALSE,
122                                       NULL);
123     }
124 
125     while (HubExtension->HubFlags & USBHUB_FDO_FLAG_WAKEUP_START)
126     {
127         USBH_Wait(10);
128     }
129 
130     return Status;
131 }
132 
133 VOID
134 NTAPI
135 USBH_IdleCancelPowerHubWorker(IN PUSBHUB_FDO_EXTENSION HubExtension,
136                               IN PVOID Context)
137 {
138     PUSBHUB_IDLE_PORT_CANCEL_CONTEXT WorkItemIdlePower;
139     PIRP Irp;
140 
141     DPRINT("USBH_IdleCancelPowerHubWorker: ... \n");
142 
143     WorkItemIdlePower = Context;
144 
145     if (HubExtension &&
146         HubExtension->CurrentPowerState.DeviceState != PowerDeviceD0 &&
147         HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED)
148     {
149         USBH_HubSetD0(HubExtension);
150     }
151 
152     Irp = WorkItemIdlePower->Irp;
153     Irp->IoStatus.Status = STATUS_CANCELLED;
154 
155     IoCompleteRequest(Irp, IO_NO_INCREMENT);
156 }
157 
158 VOID
159 NTAPI
160 USBH_HubQueuePortWakeIrps(IN PUSBHUB_FDO_EXTENSION HubExtension,
161                           IN PLIST_ENTRY ListIrps)
162 {
163     PDEVICE_OBJECT PortDevice;
164     PUSBHUB_PORT_PDO_EXTENSION PortExtension;
165     USHORT NumPorts;
166     USHORT Port;
167     PIRP WakeIrp;
168     KIRQL OldIrql;
169 
170     DPRINT("USBH_HubQueuePortWakeIrps ... \n");
171 
172     NumPorts = HubExtension->HubDescriptor->bNumberOfPorts;
173 
174     InitializeListHead(ListIrps);
175 
176     IoAcquireCancelSpinLock(&OldIrql);
177 
178     for (Port = 0; Port < NumPorts; ++Port)
179     {
180         PortDevice = HubExtension->PortData[Port].DeviceObject;
181 
182         if (PortDevice)
183         {
184             PortExtension = PortDevice->DeviceExtension;
185 
186             WakeIrp = PortExtension->PdoWaitWakeIrp;
187             PortExtension->PdoWaitWakeIrp = NULL;
188 
189             if (WakeIrp)
190             {
191                 DPRINT1("USBH_HubQueuePortWakeIrps: UNIMPLEMENTED. FIXME\n");
192                 DbgBreakPoint();
193             }
194         }
195     }
196 
197     IoReleaseCancelSpinLock(OldIrql);
198 }
199 
200 VOID
201 NTAPI
202 USBH_HubCompleteQueuedPortWakeIrps(IN PUSBHUB_FDO_EXTENSION HubExtension,
203                                    IN PLIST_ENTRY ListIrps,
204                                    IN NTSTATUS NtStatus)
205 {
206     DPRINT("USBH_HubCompleteQueuedPortWakeIrps ... \n");
207 
208     while (!IsListEmpty(ListIrps))
209     {
210         DPRINT1("USBH_HubCompleteQueuedPortWakeIrps: UNIMPLEMENTED. FIXME\n");
211         DbgBreakPoint();
212     }
213 }
214 
215 VOID
216 NTAPI
217 USBH_HubCompletePortWakeIrps(IN PUSBHUB_FDO_EXTENSION HubExtension,
218                              IN NTSTATUS NtStatus)
219 {
220     LIST_ENTRY ListIrps;
221 
222     DPRINT("USBH_HubCompletePortWakeIrps: NtStatus - %x\n", NtStatus);
223 
224     if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED)
225     {
226         USBH_HubQueuePortWakeIrps(HubExtension, &ListIrps);
227 
228         USBH_HubCompleteQueuedPortWakeIrps(HubExtension,
229                                            &ListIrps,
230                                            NtStatus);
231     }
232 }
233 
234 VOID
235 NTAPI
236 USBH_FdoPoRequestD0Completion(IN PDEVICE_OBJECT DeviceObject,
237                               IN UCHAR MinorFunction,
238                               IN POWER_STATE PowerState,
239                               IN PVOID Context,
240                               IN PIO_STATUS_BLOCK IoStatus)
241 {
242     PUSBHUB_FDO_EXTENSION HubExtension;
243 
244     DPRINT("USBH_FdoPoRequestD0Completion ... \n");
245 
246     HubExtension = Context;
247 
248     USBH_HubCompletePortWakeIrps(HubExtension, STATUS_SUCCESS);
249 
250     HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_WAKEUP_START;
251 
252     if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
253     {
254         KeSetEvent(&HubExtension->PendingRequestEvent,
255                    EVENT_INCREMENT,
256                    FALSE);
257     }
258 }
259 
260 VOID
261 NTAPI
262 USBH_CompletePortWakeIrpsWorker(IN PUSBHUB_FDO_EXTENSION HubExtension,
263                                 IN PVOID Context)
264 {
265     DPRINT1("USBH_CompletePortWakeIrpsWorker: UNIMPLEMENTED. FIXME\n");
266     DbgBreakPoint();
267 }
268 
269 NTSTATUS
270 NTAPI
271 USBH_FdoWWIrpIoCompletion(IN PDEVICE_OBJECT DeviceObject,
272                           IN PIRP Irp,
273                           IN PVOID Context)
274 {
275     PUSBHUB_FDO_EXTENSION HubExtension;
276     NTSTATUS Status;
277     KIRQL OldIrql;
278     POWER_STATE PowerState;
279     PIRP WakeIrp;
280 
281     DPRINT("USBH_FdoWWIrpIoCompletion: DeviceObject - %p, Irp - %p\n",
282             DeviceObject,
283             Irp);
284 
285     HubExtension = Context;
286 
287     Status = Irp->IoStatus.Status;
288 
289     IoAcquireCancelSpinLock(&OldIrql);
290 
291     HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_PENDING_WAKE_IRP;
292 
293     WakeIrp = InterlockedExchangePointer((PVOID *)&HubExtension->PendingWakeIrp,
294                                          NULL);
295 
296     if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
297     {
298         KeSetEvent(&HubExtension->PendingRequestEvent,
299                    EVENT_INCREMENT,
300                    FALSE);
301     }
302 
303     IoReleaseCancelSpinLock(OldIrql);
304 
305     DPRINT("USBH_FdoWWIrpIoCompletion: Status - %lX\n", Status);
306 
307     if (!NT_SUCCESS(Status))
308     {
309         DPRINT1("USBH_FdoWWIrpIoCompletion: DbgBreakPoint() \n");
310         DbgBreakPoint();
311     }
312     else
313     {
314         PowerState.DeviceState = PowerDeviceD0;
315 
316         HubExtension->HubFlags |= USBHUB_FDO_FLAG_WAKEUP_START;
317         InterlockedIncrement(&HubExtension->PendingRequestCount);
318 
319         Status = STATUS_SUCCESS;
320 
321         PoRequestPowerIrp(HubExtension->LowerPDO,
322                           IRP_MN_SET_POWER,
323                           PowerState,
324                           USBH_FdoPoRequestD0Completion,
325                           (PVOID)HubExtension,
326                           NULL);
327     }
328 
329     if (!WakeIrp)
330     {
331         if (!InterlockedExchange(&HubExtension->FdoWaitWakeLock, 1))
332         {
333             Status = STATUS_MORE_PROCESSING_REQUIRED;
334         }
335     }
336 
337     DPRINT("USBH_FdoWWIrpIoCompletion: Status - %lX\n", Status);
338 
339     if (Status != STATUS_MORE_PROCESSING_REQUIRED)
340     {
341         PoStartNextPowerIrp(Irp);
342     }
343 
344     return Status;
345 }
346 
347 NTSTATUS
348 NTAPI
349 USBH_PowerIrpCompletion(IN PDEVICE_OBJECT DeviceObject,
350                         IN PIRP Irp,
351                         IN PVOID Context)
352 {
353     PUSBHUB_FDO_EXTENSION HubExtension;
354     PIO_STACK_LOCATION IoStack;
355     DEVICE_POWER_STATE OldDeviceState;
356     NTSTATUS Status;
357     POWER_STATE PowerState;
358 
359     DPRINT("USBH_PowerIrpCompletion: DeviceObject - %p, Irp - %p\n",
360            DeviceObject,
361            Irp);
362 
363     HubExtension = Context;
364 
365     IoStack = IoGetCurrentIrpStackLocation(Irp);
366     PowerState = IoStack->Parameters.Power.State;
367 
368     Status = Irp->IoStatus.Status;
369     DPRINT("USBH_PowerIrpCompletion: Status - %lX\n", Status);
370 
371     if (!NT_SUCCESS(Status))
372     {
373         if (PowerState.DeviceState == PowerDeviceD0)
374         {
375             PoStartNextPowerIrp(Irp);
376             HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_SET_D0_STATE;
377         }
378     }
379     else if (PowerState.DeviceState == PowerDeviceD0)
380     {
381         HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_SET_D0_STATE;
382 
383         OldDeviceState = HubExtension->CurrentPowerState.DeviceState;
384         HubExtension->CurrentPowerState.DeviceState = PowerDeviceD0;
385 
386         DPRINT("USBH_PowerIrpCompletion: OldDeviceState - %x\n", OldDeviceState);
387 
388         if (HubExtension->HubFlags & USBHUB_FDO_FLAG_HIBERNATE_STATE)
389         {
390             DPRINT1("USBH_PowerIrpCompletion: USBHUB_FDO_FLAG_HIBERNATE_STATE. FIXME\n");
391             DbgBreakPoint();
392         }
393 
394         HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_HIBERNATE_STATE;
395 
396         if (OldDeviceState == PowerDeviceD3)
397         {
398             DPRINT1("USBH_PowerIrpCompletion: PowerDeviceD3. FIXME\n");
399             DbgBreakPoint();
400         }
401 
402         if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPED) &&
403             HubExtension->HubFlags & USBHUB_FDO_FLAG_DO_ENUMERATION)
404         {
405             USBH_SubmitStatusChangeTransfer(HubExtension);
406         }
407 
408         DPRINT("USBH_PowerIrpCompletion: Status - %lX\n", Status);
409 
410         if (Status != STATUS_MORE_PROCESSING_REQUIRED)
411         {
412             PoStartNextPowerIrp(Irp);
413             return Status;
414         }
415     }
416 
417     return Status;
418 }
419 
420 VOID
421 NTAPI
422 USBH_FdoDeferPoRequestCompletion(IN PDEVICE_OBJECT DeviceObject,
423                                  IN UCHAR MinorFunction,
424                                  IN POWER_STATE PowerState,
425                                  IN PVOID Context,
426                                  IN PIO_STATUS_BLOCK IoStatus)
427 {
428     PUSBHUB_FDO_EXTENSION Extension;
429     PUSBHUB_FDO_EXTENSION HubExtension = NULL;
430     PIRP PowerIrp;
431     PIO_STACK_LOCATION IoStack;
432 
433     DPRINT("USBH_FdoDeferPoRequestCompletion ... \n");
434 
435     Extension = Context;
436 
437     PowerIrp = Extension->PowerIrp;
438 
439     if (Extension->Common.ExtensionType == USBH_EXTENSION_TYPE_HUB)
440     {
441         HubExtension = Context;
442     }
443 
444     IoStack = IoGetCurrentIrpStackLocation(PowerIrp);
445 
446     if (IoStack->Parameters.Power.State.SystemState == PowerSystemWorking &&
447         HubExtension && HubExtension->LowerPDO == HubExtension->RootHubPdo)
448     {
449         HubExtension->SystemPowerState.SystemState = PowerSystemWorking;
450         USBH_CheckIdleDeferred(HubExtension);
451     }
452 
453     IoCopyCurrentIrpStackLocationToNext(PowerIrp);
454     PoStartNextPowerIrp(PowerIrp);
455     PoCallDriver(Extension->LowerDevice, PowerIrp);
456 }
457 
458 NTSTATUS
459 NTAPI
460 USBH_FdoPower(IN PUSBHUB_FDO_EXTENSION HubExtension,
461               IN PIRP Irp,
462               IN UCHAR Minor)
463 {
464     NTSTATUS Status;
465     PIO_STACK_LOCATION IoStack;
466     POWER_STATE PowerState;
467     POWER_STATE DevicePwrState;
468     BOOLEAN IsAllPortsD3;
469     PUSBHUB_PORT_DATA PortData;
470     PDEVICE_OBJECT PdoDevice;
471     PUSBHUB_PORT_PDO_EXTENSION PortExtension;
472     ULONG Port;
473 
474     DPRINT_PWR("USBH_FdoPower: HubExtension - %p, Irp - %p, Minor - %X\n",
475                HubExtension,
476                Irp,
477                Minor);
478 
479     switch (Minor)
480     {
481         case IRP_MN_WAIT_WAKE:
482             DPRINT_PWR("USBH_FdoPower: IRP_MN_WAIT_WAKE\n");
483 
484             IoCopyCurrentIrpStackLocationToNext(Irp);
485 
486             IoSetCompletionRoutine(Irp,
487                                    USBH_FdoWWIrpIoCompletion,
488                                    HubExtension,
489                                    TRUE,
490                                    TRUE,
491                                    TRUE);
492 
493             PoStartNextPowerIrp(Irp);
494             IoMarkIrpPending(Irp);
495             PoCallDriver(HubExtension->LowerDevice, Irp);
496 
497             return STATUS_PENDING;
498 
499         case IRP_MN_POWER_SEQUENCE:
500             DPRINT_PWR("USBH_FdoPower: IRP_MN_POWER_SEQUENCE\n");
501             break;
502 
503         case IRP_MN_SET_POWER:
504             DPRINT_PWR("USBH_FdoPower: IRP_MN_SET_POWER\n");
505 
506             IoStack = IoGetCurrentIrpStackLocation(Irp);
507             DPRINT_PWR("USBH_FdoPower: IRP_MN_SET_POWER/DevicePowerState\n");
508             PowerState = IoStack->Parameters.Power.State;
509 
510             if (IoStack->Parameters.Power.Type == DevicePowerState)
511             {
512                 DPRINT_PWR("USBH_FdoPower: PowerState - %x\n",
513                            PowerState.DeviceState);
514 
515                 if (HubExtension->CurrentPowerState.DeviceState == PowerState.DeviceState)
516                 {
517                     IoCopyCurrentIrpStackLocationToNext(Irp);
518 
519                     PoStartNextPowerIrp(Irp);
520                     IoMarkIrpPending(Irp);
521                     PoCallDriver(HubExtension->LowerDevice, Irp);
522 
523                     return STATUS_PENDING;
524                 }
525 
526                 switch (PowerState.DeviceState)
527                 {
528                     case PowerDeviceD0:
529                         if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_SET_D0_STATE))
530                         {
531                             HubExtension->HubFlags &= ~(USBHUB_FDO_FLAG_NOT_D0_STATE |
532                                                         USBHUB_FDO_FLAG_DEVICE_STOPPING);
533 
534                             HubExtension->HubFlags |= USBHUB_FDO_FLAG_SET_D0_STATE;
535 
536                             IoCopyCurrentIrpStackLocationToNext(Irp);
537 
538                             IoSetCompletionRoutine(Irp,
539                                                    USBH_PowerIrpCompletion,
540                                                    HubExtension,
541                                                    TRUE,
542                                                    TRUE,
543                                                    TRUE);
544                         }
545                         else
546                         {
547                             IoCopyCurrentIrpStackLocationToNext(Irp);
548                             PoStartNextPowerIrp(Irp);
549                         }
550 
551                         IoMarkIrpPending(Irp);
552                         PoCallDriver(HubExtension->LowerDevice, Irp);
553                         return STATUS_PENDING;
554 
555                     case PowerDeviceD1:
556                     case PowerDeviceD2:
557                     case PowerDeviceD3:
558                         if (HubExtension->ResetRequestCount)
559                         {
560                             IoCancelIrp(HubExtension->ResetPortIrp);
561 
562                             KeWaitForSingleObject(&HubExtension->ResetEvent,
563                                                   Executive,
564                                                   KernelMode,
565                                                   FALSE,
566                                                   NULL);
567                         }
568 
569                         if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPED))
570                         {
571                             HubExtension->HubFlags |= (USBHUB_FDO_FLAG_NOT_D0_STATE |
572                                                        USBHUB_FDO_FLAG_DEVICE_STOPPING);
573 
574                             IoCancelIrp(HubExtension->SCEIrp);
575 
576                             KeWaitForSingleObject(&HubExtension->StatusChangeEvent,
577                                                   Executive,
578                                                   KernelMode,
579                                                   FALSE,
580                                                   NULL);
581                         }
582 
583                         HubExtension->CurrentPowerState.DeviceState = PowerState.DeviceState;
584 
585                         if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DO_SUSPENSE &&
586                             USBH_CheckIdleAbort(HubExtension, TRUE, TRUE) == TRUE)
587                         {
588                             HubExtension->HubFlags &= ~(USBHUB_FDO_FLAG_NOT_D0_STATE |
589                                                         USBHUB_FDO_FLAG_DEVICE_STOPPING);
590 
591                             HubExtension->CurrentPowerState.DeviceState = PowerDeviceD0;
592 
593                             USBH_SubmitStatusChangeTransfer(HubExtension);
594 
595                             PoStartNextPowerIrp(Irp);
596 
597                             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
598                             IoCompleteRequest(Irp, IO_NO_INCREMENT);
599 
600                             HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_DO_SUSPENSE;
601 
602                             KeReleaseSemaphore(&HubExtension->IdleSemaphore,
603                                                LOW_REALTIME_PRIORITY,
604                                                1,
605                                                FALSE);
606 
607                             return STATUS_UNSUCCESSFUL;
608                         }
609 
610                         IoCopyCurrentIrpStackLocationToNext(Irp);
611 
612                         IoSetCompletionRoutine(Irp,
613                                                USBH_PowerIrpCompletion,
614                                                HubExtension,
615                                                TRUE,
616                                                TRUE,
617                                                TRUE);
618 
619                         PoStartNextPowerIrp(Irp);
620                         IoMarkIrpPending(Irp);
621                         PoCallDriver(HubExtension->LowerDevice, Irp);
622 
623                         if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DO_SUSPENSE)
624                         {
625                             HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_DO_SUSPENSE;
626 
627                             KeReleaseSemaphore(&HubExtension->IdleSemaphore,
628                                                LOW_REALTIME_PRIORITY,
629                                                1,
630                                                FALSE);
631                         }
632 
633                         return STATUS_PENDING;
634 
635                     default:
636                         DPRINT1("USBH_FdoPower: Unsupported PowerState.DeviceState\n");
637                         DbgBreakPoint();
638                         break;
639                 }
640             }
641             else
642             {
643                 if (PowerState.SystemState != PowerSystemWorking)
644                 {
645                     USBH_GetRootHubExtension(HubExtension)->SystemPowerState.SystemState =
646                                                             PowerState.SystemState;
647                 }
648 
649                 if (PowerState.SystemState == PowerSystemHibernate)
650                 {
651                     HubExtension->HubFlags |= USBHUB_FDO_FLAG_HIBERNATE_STATE;
652                 }
653 
654                 PortData = HubExtension->PortData;
655 
656                 IsAllPortsD3 = TRUE;
657 
658                 if (PortData && HubExtension->HubDescriptor)
659                 {
660                     for (Port = 0;
661                          Port < HubExtension->HubDescriptor->bNumberOfPorts;
662                          Port++)
663                     {
664                         PdoDevice = PortData[Port].DeviceObject;
665 
666                         if (PdoDevice)
667                         {
668                             PortExtension = PdoDevice->DeviceExtension;
669 
670                             if (PortExtension->CurrentPowerState.DeviceState != PowerDeviceD3)
671                             {
672                                 IsAllPortsD3 = FALSE;
673                                 break;
674                             }
675                         }
676                     }
677                 }
678 
679                 if (PowerState.SystemState == PowerSystemWorking)
680                 {
681                     DevicePwrState.DeviceState = PowerDeviceD0;
682                 }
683                 else if (HubExtension->HubFlags & USBHUB_FDO_FLAG_PENDING_WAKE_IRP ||
684                          !IsAllPortsD3)
685                 {
686                     DevicePwrState.DeviceState = HubExtension->DeviceState[PowerState.SystemState];
687 
688                     if (DevicePwrState.DeviceState == PowerDeviceUnspecified)
689                     {
690                         goto Exit;
691                     }
692                 }
693                 else
694                 {
695                     DevicePwrState.DeviceState = PowerDeviceD3;
696                 }
697 
698                 if (DevicePwrState.DeviceState != HubExtension->CurrentPowerState.DeviceState &&
699                     HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED)
700                 {
701                     HubExtension->PowerIrp = Irp;
702 
703                     IoMarkIrpPending(Irp);
704 
705                     if (PoRequestPowerIrp(HubExtension->LowerPDO,
706                                           IRP_MN_SET_POWER,
707                                           DevicePwrState,
708                                           USBH_FdoDeferPoRequestCompletion,
709                                           (PVOID)HubExtension,
710                                           NULL) == STATUS_PENDING)
711                     {
712                         return STATUS_PENDING;
713                     }
714 
715                     IoCopyCurrentIrpStackLocationToNext(Irp);
716                     PoStartNextPowerIrp(Irp);
717                     PoCallDriver(HubExtension->LowerDevice, Irp);
718 
719                     return STATUS_PENDING;
720                 }
721 
722             Exit:
723 
724                 HubExtension->SystemPowerState.SystemState = PowerState.SystemState;
725 
726                 if (PowerState.SystemState == PowerSystemWorking)
727                 {
728                     USBH_CheckIdleDeferred(HubExtension);
729                 }
730 
731                 IoCopyCurrentIrpStackLocationToNext(Irp);
732                 PoStartNextPowerIrp(Irp);
733 
734                 return PoCallDriver(HubExtension->LowerDevice, Irp);
735             }
736 
737             break;
738 
739         case IRP_MN_QUERY_POWER:
740             DPRINT_PWR("USBH_FdoPower: IRP_MN_QUERY_POWER\n");
741             break;
742 
743         default:
744             DPRINT1("USBH_FdoPower: unknown IRP_MN_POWER!\n");
745             break;
746     }
747 
748     IoCopyCurrentIrpStackLocationToNext(Irp);
749     PoStartNextPowerIrp(Irp);
750     Status = PoCallDriver(HubExtension->LowerDevice, Irp);
751 
752     return Status;
753 }
754 
755 NTSTATUS
756 NTAPI
757 USBH_PdoPower(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
758               IN PIRP Irp,
759               IN UCHAR Minor)
760 {
761     NTSTATUS Status = Irp->IoStatus.Status;
762 
763     DPRINT_PWR("USBH_FdoPower: PortExtension - %p, Irp - %p, Minor - %X\n",
764                PortExtension,
765                Irp,
766                Minor);
767 
768     switch (Minor)
769     {
770       case IRP_MN_WAIT_WAKE:
771           DPRINT_PWR("USBHUB_PdoPower: IRP_MN_WAIT_WAKE\n");
772           PoStartNextPowerIrp(Irp);
773           break;
774 
775       case IRP_MN_POWER_SEQUENCE:
776           DPRINT_PWR("USBHUB_PdoPower: IRP_MN_POWER_SEQUENCE\n");
777           PoStartNextPowerIrp(Irp);
778           break;
779 
780       case IRP_MN_SET_POWER:
781           DPRINT_PWR("USBHUB_PdoPower: IRP_MN_SET_POWER\n");
782           PoStartNextPowerIrp(Irp);
783           break;
784 
785       case IRP_MN_QUERY_POWER:
786           DPRINT_PWR("USBHUB_PdoPower: IRP_MN_QUERY_POWER\n");
787           PoStartNextPowerIrp(Irp);
788           break;
789 
790       default:
791           DPRINT1("USBHUB_PdoPower: unknown IRP_MN_POWER!\n");
792           PoStartNextPowerIrp(Irp);
793           break;
794     }
795 
796     Irp->IoStatus.Status = Status;
797     Irp->IoStatus.Information = 0;
798     IoCompleteRequest(Irp, IO_NO_INCREMENT);
799 
800     return Status;
801 }
802