[USBPORT] Check Period instead Factor.
[reactos.git] / drivers / usb / usbport / endpoint.c
1 /*
2 * PROJECT: ReactOS USB Port Driver
3 * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4 * PURPOSE: USBPort endpoint functions
5 * COPYRIGHT: Copyright 2017 Vadim Galyant <vgal@rambler.ru>
6 */
7
8 #include "usbport.h"
9
10 #define NDEBUG
11 #include <debug.h>
12
13 #define NDEBUG_USBPORT_CORE
14 #include "usbdebug.h"
15
16 ULONG
17 NTAPI
18 USBPORT_CalculateUsbBandwidth(IN PDEVICE_OBJECT FdoDevice,
19 IN PUSBPORT_ENDPOINT Endpoint)
20 {
21 PUSBPORT_ENDPOINT_PROPERTIES EndpointProperties;
22 ULONG Bandwidth;
23 ULONG Overhead;
24
25 DPRINT("USBPORT_CalculateUsbBandwidth ... \n");
26
27 EndpointProperties = &Endpoint->EndpointProperties;
28
29 switch (EndpointProperties->TransferType)
30 {
31 case USBPORT_TRANSFER_TYPE_ISOCHRONOUS:
32 Overhead = USB2_FS_ISOCHRONOUS_OVERHEAD;
33 break;
34
35 case USBPORT_TRANSFER_TYPE_INTERRUPT:
36 Overhead = USB2_FS_INTERRUPT_OVERHEAD;
37 break;
38
39 default: //USBPORT_TRANSFER_TYPE_CONTROL or USBPORT_TRANSFER_TYPE_BULK
40 Overhead = 0;
41 break;
42 }
43
44 if (Overhead == 0)
45 {
46 Bandwidth = 0;
47 }
48 else
49 {
50 Bandwidth = (EndpointProperties->TotalMaxPacketSize + Overhead) * 8 * 7 / 6;
51 }
52
53 if (EndpointProperties->DeviceSpeed == UsbLowSpeed)
54 {
55 Bandwidth *= 8;
56 }
57
58 return Bandwidth;
59 }
60
61 BOOLEAN
62 NTAPI
63 USBPORT_AllocateBandwidth(IN PDEVICE_OBJECT FdoDevice,
64 IN PUSBPORT_ENDPOINT Endpoint)
65 {
66 PUSBPORT_DEVICE_EXTENSION FdoExtension;
67 PUSBPORT_ENDPOINT_PROPERTIES EndpointProperties;
68 ULONG TransferType;
69 ULONG TotalBusBandwidth;
70 ULONG EndpointBandwidth;
71 ULONG MinBandwidth;
72 PULONG Bandwidth;
73 ULONG MaxBandwidth = 0;
74 ULONG ix;
75 ULONG Offset;
76 LONG ScheduleOffset = -1;
77 ULONG Period;
78 ULONG Factor;
79 UCHAR Bit;
80
81 DPRINT("USBPORT_AllocateBandwidth: FdoDevice - %p, Endpoint - %p\n",
82 FdoDevice,
83 Endpoint);
84
85 FdoExtension = FdoDevice->DeviceExtension;
86 EndpointProperties = &Endpoint->EndpointProperties;
87 TransferType = EndpointProperties->TransferType;
88
89 if (TransferType == USBPORT_TRANSFER_TYPE_BULK ||
90 TransferType == USBPORT_TRANSFER_TYPE_CONTROL ||
91 Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0)
92 {
93 EndpointProperties->ScheduleOffset = 0;
94 return TRUE;
95 }
96
97 TotalBusBandwidth = FdoExtension->TotalBusBandwidth;
98 EndpointBandwidth = EndpointProperties->UsbBandwidth;
99
100 Period = EndpointProperties->Period;
101 ASSERT(Period != 0);
102 Factor = USB2_FRAMES / Period;
103
104 for (Offset = 0; Offset < Period; Offset++)
105 {
106 MinBandwidth = TotalBusBandwidth;
107 Bandwidth = &FdoExtension->Bandwidth[Offset * Factor];
108
109 for (ix = 1; *Bandwidth >= EndpointBandwidth; ix++)
110 {
111 MinBandwidth = min(MinBandwidth, *Bandwidth);
112
113 Bandwidth++;
114
115 if (Factor <= ix)
116 {
117 if (MinBandwidth > MaxBandwidth)
118 {
119 MaxBandwidth = MinBandwidth;
120 ScheduleOffset = Offset;
121
122 DPRINT("USBPORT_AllocateBandwidth: ScheduleOffset - %X\n",
123 ScheduleOffset);
124 }
125
126 break;
127 }
128 }
129 }
130
131 DPRINT("USBPORT_AllocateBandwidth: ScheduleOffset - %X\n", ScheduleOffset);
132
133 if (ScheduleOffset != -1)
134 {
135 EndpointProperties->ScheduleOffset = ScheduleOffset;
136
137 Bandwidth = &FdoExtension->Bandwidth[ScheduleOffset * Factor];
138
139 for (Factor = USB2_FRAMES / Period; Factor; Factor--)
140 {
141 FdoExtension->Bandwidth[ScheduleOffset * Factor] -= EndpointBandwidth;
142 }
143
144 if (TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT)
145 {
146 for (Bit = 0x80; Bit != 0; Bit >>= 1)
147 {
148 if ((Period & Bit) != 0)
149 {
150 Period = Bit;
151 break;
152 }
153 }
154
155 DPRINT("USBPORT_AllocateBandwidth: FIXME AllocatedInterrupt_XXms\n");
156 }
157 else
158 {
159 DPRINT("USBPORT_AllocateBandwidth: FIXME AllocatedIso\n");
160 }
161 }
162
163 DPRINT("USBPORT_AllocateBandwidth: FIXME USBPORT_UpdateAllocatedBw\n");
164
165 DPRINT("USBPORT_AllocateBandwidth: ScheduleOffset - %X\n", ScheduleOffset);
166 return ScheduleOffset != -1;
167 }
168
169 VOID
170 NTAPI
171 USBPORT_FreeBandwidth(IN PDEVICE_OBJECT FdoDevice,
172 IN PUSBPORT_ENDPOINT Endpoint)
173 {
174 PUSBPORT_DEVICE_EXTENSION FdoExtension;
175 PUSBPORT_ENDPOINT_PROPERTIES EndpointProperties;
176 ULONG TransferType;
177 ULONG Offset;
178 ULONG EndpointBandwidth;
179 ULONG Period;
180 ULONG Factor;
181 UCHAR Bit;
182
183 DPRINT("USBPORT_FreeBandwidth: FdoDevice - %p, Endpoint - %p\n",
184 FdoDevice,
185 Endpoint);
186
187 FdoExtension = FdoDevice->DeviceExtension;
188
189 EndpointProperties = &Endpoint->EndpointProperties;
190 TransferType = EndpointProperties->TransferType;
191
192 if (TransferType == USBPORT_TRANSFER_TYPE_BULK ||
193 TransferType == USBPORT_TRANSFER_TYPE_CONTROL ||
194 (Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0))
195 {
196 return;
197 }
198
199 Offset = Endpoint->EndpointProperties.ScheduleOffset;
200 EndpointBandwidth = Endpoint->EndpointProperties.UsbBandwidth;
201
202 Period = Endpoint->EndpointProperties.Period;
203 ASSERT(Period != 0);
204
205 for (Factor = USB2_FRAMES / Period; Factor; Factor--)
206 {
207 FdoExtension->Bandwidth[Offset * Factor] += EndpointBandwidth;
208 }
209
210 if (TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT)
211 {
212 for (Bit = 0x80; Bit != 0; Bit >>= 1)
213 {
214 if ((Period & Bit) != 0)
215 {
216 Period = Bit;
217 break;
218 }
219 }
220
221 ASSERT(Period != 0);
222
223 DPRINT("USBPORT_AllocateBandwidth: FIXME AllocatedInterrupt_XXms\n");
224 }
225 else
226 {
227 DPRINT("USBPORT_AllocateBandwidth: FIXME AllocatedIso\n");
228 }
229
230 DPRINT1("USBPORT_FreeBandwidth: FIXME USBPORT_UpdateAllocatedBw\n");
231 }
232
233 UCHAR
234 NTAPI
235 USBPORT_NormalizeHsInterval(UCHAR Interval)
236 {
237 UCHAR interval;
238
239 DPRINT("USBPORT_NormalizeHsInterval: Interval - %x\n", Interval);
240
241 interval = Interval;
242
243 if (Interval)
244 interval = Interval - 1;
245
246 if (interval > 5)
247 interval = 5;
248
249 return 1 << interval;
250 }
251
252 BOOLEAN
253 NTAPI
254 USBPORT_EndpointHasQueuedTransfers(IN PDEVICE_OBJECT FdoDevice,
255 IN PUSBPORT_ENDPOINT Endpoint,
256 IN PULONG TransferCount)
257 {
258 PLIST_ENTRY Entry;
259 PUSBPORT_TRANSFER Transfer;
260 BOOLEAN Result = FALSE;
261
262 DPRINT_CORE("USBPORT_EndpointHasQueuedTransfers: ... \n");
263
264 KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
265
266 if (!IsListEmpty(&Endpoint->PendingTransferList))
267 Result = TRUE;
268
269 if (!IsListEmpty(&Endpoint->TransferList))
270 {
271 Result = TRUE;
272
273 if (TransferCount)
274 {
275 *TransferCount = 0;
276
277 for (Entry = Endpoint->TransferList.Flink;
278 Entry && Entry != &Endpoint->TransferList;
279 Entry = Transfer->TransferLink.Flink)
280 {
281 Transfer = CONTAINING_RECORD(Entry,
282 USBPORT_TRANSFER,
283 TransferLink);
284
285 if (Transfer->Flags & TRANSFER_FLAG_SUBMITED)
286 {
287 ++*TransferCount;
288 }
289 }
290 }
291 }
292
293 KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
294
295 return Result;
296 }
297
298 VOID
299 NTAPI
300 USBPORT_NukeAllEndpoints(IN PDEVICE_OBJECT FdoDevice)
301 {
302 PUSBPORT_DEVICE_EXTENSION FdoExtension;
303 PLIST_ENTRY EndpointList;
304 PUSBPORT_ENDPOINT Endpoint;
305 KIRQL OldIrql;
306
307 DPRINT("USBPORT_NukeAllEndpoints \n");
308
309 FdoExtension = FdoDevice->DeviceExtension;
310
311 KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
312
313 EndpointList = FdoExtension->EndpointList.Flink;
314
315 while (EndpointList && (EndpointList != &FdoExtension->EndpointList))
316 {
317 Endpoint = CONTAINING_RECORD(EndpointList,
318 USBPORT_ENDPOINT,
319 EndpointLink);
320
321 if (!(Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0))
322 Endpoint->Flags |= ENDPOINT_FLAG_NUKE;
323
324 EndpointList = Endpoint->EndpointLink.Flink;
325 }
326
327 KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
328 }
329
330 ULONG
331 NTAPI
332 USBPORT_GetEndpointState(IN PUSBPORT_ENDPOINT Endpoint)
333 {
334 ULONG State;
335
336 //DPRINT("USBPORT_GetEndpointState \n");
337
338 KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
339
340 if (Endpoint->StateLast != Endpoint->StateNext)
341 {
342 State = USBPORT_ENDPOINT_UNKNOWN;
343 }
344 else
345 {
346 State = Endpoint->StateLast;
347 }
348
349 KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
350
351 if (State != USBPORT_ENDPOINT_ACTIVE)
352 {
353 DPRINT("USBPORT_GetEndpointState: Endpoint - %p, State - %x\n",
354 Endpoint,
355 State);
356 }
357
358 return State;
359 }
360
361 VOID
362 NTAPI
363 USBPORT_SetEndpointState(IN PUSBPORT_ENDPOINT Endpoint,
364 IN ULONG State)
365 {
366 PDEVICE_OBJECT FdoDevice;
367 PUSBPORT_DEVICE_EXTENSION FdoExtension;
368 PUSBPORT_REGISTRATION_PACKET Packet;
369 KIRQL OldIrql;
370
371 DPRINT("USBPORT_SetEndpointState: Endpoint - %p, State - %x\n",
372 Endpoint,
373 State);
374
375 FdoDevice = Endpoint->FdoDevice;
376 FdoExtension = FdoDevice->DeviceExtension;
377 Packet = &FdoExtension->MiniPortInterface->Packet;
378
379 KeAcquireSpinLock(&Endpoint->StateChangeSpinLock,
380 &Endpoint->EndpointStateOldIrql);
381
382 if (!(Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0))
383 {
384 if (Endpoint->Flags & ENDPOINT_FLAG_NUKE)
385 {
386 Endpoint->StateLast = State;
387 Endpoint->StateNext = State;
388
389 KeReleaseSpinLock(&Endpoint->StateChangeSpinLock,
390 Endpoint->EndpointStateOldIrql);
391
392 USBPORT_InvalidateEndpointHandler(FdoDevice,
393 Endpoint,
394 INVALIDATE_ENDPOINT_WORKER_THREAD);
395 return;
396 }
397
398 KeReleaseSpinLock(&Endpoint->StateChangeSpinLock,
399 Endpoint->EndpointStateOldIrql);
400
401 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
402 Packet->SetEndpointState(FdoExtension->MiniPortExt,
403 Endpoint + 1,
404 State);
405 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
406
407 Endpoint->StateNext = State;
408
409 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
410 Endpoint->FrameNumber = Packet->Get32BitFrameNumber(FdoExtension->MiniPortExt);
411 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
412
413 ExInterlockedInsertTailList(&FdoExtension->EpStateChangeList,
414 &Endpoint->StateChangeLink,
415 &FdoExtension->EpStateChangeSpinLock);
416
417 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
418 Packet->InterruptNextSOF(FdoExtension->MiniPortExt);
419 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
420 }
421 else
422 {
423 Endpoint->StateLast = State;
424 Endpoint->StateNext = State;
425
426 if (State == USBPORT_ENDPOINT_REMOVE)
427 {
428 KeReleaseSpinLock(&Endpoint->StateChangeSpinLock,
429 Endpoint->EndpointStateOldIrql);
430
431 USBPORT_InvalidateEndpointHandler(FdoDevice,
432 Endpoint,
433 INVALIDATE_ENDPOINT_WORKER_THREAD);
434 return;
435 }
436
437 KeReleaseSpinLock(&Endpoint->StateChangeSpinLock,
438 Endpoint->EndpointStateOldIrql);
439 }
440 }
441
442 VOID
443 NTAPI
444 USBPORT_AddPipeHandle(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
445 IN PUSBPORT_PIPE_HANDLE PipeHandle)
446 {
447 DPRINT("USBPORT_AddPipeHandle: DeviceHandle - %p, PipeHandle - %p\n",
448 DeviceHandle,
449 PipeHandle);
450
451 InsertTailList(&DeviceHandle->PipeHandleList, &PipeHandle->PipeLink);
452 }
453
454 VOID
455 NTAPI
456 USBPORT_RemovePipeHandle(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
457 IN PUSBPORT_PIPE_HANDLE PipeHandle)
458 {
459 DPRINT("USBPORT_RemovePipeHandle: PipeHandle - %p\n", PipeHandle);
460
461 RemoveEntryList(&PipeHandle->PipeLink);
462
463 PipeHandle->PipeLink.Flink = NULL;
464 PipeHandle->PipeLink.Blink = NULL;
465 }
466
467 BOOLEAN
468 NTAPI
469 USBPORT_ValidatePipeHandle(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
470 IN PUSBPORT_PIPE_HANDLE PipeHandle)
471 {
472 PLIST_ENTRY HandleList;
473 PUSBPORT_PIPE_HANDLE CurrentHandle;
474
475 //DPRINT("USBPORT_ValidatePipeHandle: DeviceHandle - %p, PipeHandle - %p\n",
476 // DeviceHandle,
477 // PipeHandle);
478
479 HandleList = DeviceHandle->PipeHandleList.Flink;
480
481 while (HandleList != &DeviceHandle->PipeHandleList)
482 {
483 CurrentHandle = CONTAINING_RECORD(HandleList,
484 USBPORT_PIPE_HANDLE,
485 PipeLink);
486
487 HandleList = HandleList->Flink;
488
489 if (CurrentHandle == PipeHandle)
490 return TRUE;
491 }
492
493 return FALSE;
494 }
495
496 BOOLEAN
497 NTAPI
498 USBPORT_DeleteEndpoint(IN PDEVICE_OBJECT FdoDevice,
499 IN PUSBPORT_ENDPOINT Endpoint)
500 {
501 PUSBPORT_DEVICE_EXTENSION FdoExtension;
502 BOOLEAN Result;
503 KIRQL OldIrql;
504
505 DPRINT1("USBPORT_DeleteEndpoint: Endpoint - %p\n", Endpoint);
506
507 FdoExtension = FdoDevice->DeviceExtension;
508
509 if ((Endpoint->WorkerLink.Flink && Endpoint->WorkerLink.Blink) ||
510 Endpoint->LockCounter != -1)
511 {
512 KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
513
514 ExInterlockedInsertTailList(&FdoExtension->EndpointClosedList,
515 &Endpoint->CloseLink,
516 &FdoExtension->EndpointClosedSpinLock);
517
518 KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
519
520 Result = FALSE;
521 }
522 else
523 {
524 KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
525
526 RemoveEntryList(&Endpoint->EndpointLink);
527 Endpoint->EndpointLink.Flink = NULL;
528 Endpoint->EndpointLink.Blink = NULL;
529
530 KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
531
532 MiniportCloseEndpoint(FdoDevice, Endpoint);
533
534 if (Endpoint->HeaderBuffer)
535 {
536 USBPORT_FreeCommonBuffer(FdoDevice, Endpoint->HeaderBuffer);
537 }
538
539 ExFreePoolWithTag(Endpoint, USB_PORT_TAG);
540
541 Result = TRUE;
542 }
543
544 return Result;
545 }
546
547 VOID
548 NTAPI
549 MiniportCloseEndpoint(IN PDEVICE_OBJECT FdoDevice,
550 IN PUSBPORT_ENDPOINT Endpoint)
551 {
552 PUSBPORT_DEVICE_EXTENSION FdoExtension;
553 PUSBPORT_REGISTRATION_PACKET Packet;
554 BOOLEAN IsDoDisablePeriodic;
555 ULONG TransferType;
556 KIRQL OldIrql;
557
558 DPRINT("MiniportCloseEndpoint: Endpoint - %p\n", Endpoint);
559
560 FdoExtension = FdoDevice->DeviceExtension;
561 Packet = &FdoExtension->MiniPortInterface->Packet;
562
563 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
564
565 if (Endpoint->Flags & ENDPOINT_FLAG_OPENED)
566 {
567 TransferType = Endpoint->EndpointProperties.TransferType;
568
569 if (TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT ||
570 TransferType == USBPORT_TRANSFER_TYPE_ISOCHRONOUS)
571 {
572 --FdoExtension->PeriodicEndpoints;
573 }
574
575 IsDoDisablePeriodic = FdoExtension->PeriodicEndpoints == 0;
576
577 Packet->CloseEndpoint(FdoExtension->MiniPortExt,
578 Endpoint + 1,
579 IsDoDisablePeriodic);
580
581 Endpoint->Flags &= ~ENDPOINT_FLAG_OPENED;
582 Endpoint->Flags |= ENDPOINT_FLAG_CLOSED;
583 }
584
585 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
586 }
587
588 VOID
589 NTAPI
590 USBPORT_ClosePipe(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
591 IN PDEVICE_OBJECT FdoDevice,
592 IN PUSBPORT_PIPE_HANDLE PipeHandle)
593 {
594 PUSBPORT_DEVICE_EXTENSION FdoExtension;
595 PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
596 PUSBPORT_ENDPOINT Endpoint;
597 PUSBPORT_REGISTRATION_PACKET Packet;
598 PUSB2_TT_EXTENSION TtExtension;
599 ULONG ix;
600 BOOLEAN IsReady;
601 KIRQL OldIrql;
602
603 DPRINT1("USBPORT_ClosePipe \n");
604
605 FdoExtension = FdoDevice->DeviceExtension;
606
607 if (PipeHandle->Flags & PIPE_HANDLE_FLAG_CLOSED)
608 return;
609
610 USBPORT_RemovePipeHandle(DeviceHandle, PipeHandle);
611
612 PipeHandle->Flags |= PIPE_HANDLE_FLAG_CLOSED;
613
614 if (PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE)
615 {
616 PipeHandle->Flags &= ~PIPE_HANDLE_FLAG_NULL_PACKET_SIZE;
617 return;
618 }
619
620 Endpoint = PipeHandle->Endpoint;
621
622 KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
623
624 if ((Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0) &&
625 (Endpoint->EndpointProperties.TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT))
626 {
627 PdoExtension = FdoExtension->RootHubPdo->DeviceExtension;
628 PdoExtension->Endpoint = NULL;
629 }
630
631 KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
632
633 while (TRUE)
634 {
635 IsReady = TRUE;
636
637 KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
638 &Endpoint->EndpointOldIrql);
639
640 if (!IsListEmpty(&Endpoint->PendingTransferList))
641 IsReady = FALSE;
642
643 if (!IsListEmpty(&Endpoint->TransferList))
644 IsReady = FALSE;
645
646 if (!IsListEmpty(&Endpoint->CancelList))
647 IsReady = FALSE;
648
649 if (!IsListEmpty(&Endpoint->AbortList))
650 IsReady = FALSE;
651
652 KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
653 if (Endpoint->StateLast != Endpoint->StateNext)
654 IsReady = FALSE;
655 KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
656
657 KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
658 Endpoint->EndpointOldIrql);
659
660 if (InterlockedIncrement(&Endpoint->LockCounter))
661 IsReady = FALSE;
662 InterlockedDecrement(&Endpoint->LockCounter);
663
664 if (IsReady == TRUE)
665 break;
666
667 USBPORT_Wait(FdoDevice, 1);
668 }
669
670 Endpoint->DeviceHandle = NULL;
671 Packet = &FdoExtension->MiniPortInterface->Packet;
672
673 if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
674 {
675 USBPORT_FreeBandwidthUSB2(FdoDevice, Endpoint);
676
677 KeAcquireSpinLock(&FdoExtension->TtSpinLock, &OldIrql);
678
679 TtExtension = Endpoint->TtExtension;
680 DPRINT1("USBPORT_ClosePipe: TtExtension - %p\n", TtExtension);
681
682 if (TtExtension)
683 {
684 RemoveEntryList(&Endpoint->TtLink);
685
686 Endpoint->TtLink.Flink = NULL;
687 Endpoint->TtLink.Blink = NULL;
688
689 if (TtExtension->Flags & USB2_TT_EXTENSION_FLAG_DELETED)
690 {
691 if (IsListEmpty(&TtExtension->EndpointList))
692 {
693 USBPORT_UpdateAllocatedBwTt(TtExtension);
694
695 for (ix = 0; ix < USB2_FRAMES; ix++)
696 {
697 FdoExtension->Bandwidth[ix] += TtExtension->MaxBandwidth;
698 }
699
700 DPRINT1("USBPORT_ClosePipe: ExFreePoolWithTag TtExtension - %p\n", TtExtension);
701 ExFreePoolWithTag(TtExtension, USB_PORT_TAG);
702 }
703 }
704 }
705
706 KeReleaseSpinLock(&FdoExtension->TtSpinLock, OldIrql);
707 }
708 else
709 {
710 USBPORT_FreeBandwidth(FdoDevice, Endpoint);
711 }
712
713 KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
714 USBPORT_SetEndpointState(Endpoint, USBPORT_ENDPOINT_REMOVE);
715 KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
716
717 USBPORT_SignalWorkerThread(FdoDevice);
718 }
719
720 MPSTATUS
721 NTAPI
722 MiniportOpenEndpoint(IN PDEVICE_OBJECT FdoDevice,
723 IN PUSBPORT_ENDPOINT Endpoint)
724 {
725 PUSBPORT_DEVICE_EXTENSION FdoExtension;
726 PUSBPORT_REGISTRATION_PACKET Packet;
727 KIRQL OldIrql;
728 ULONG TransferType;
729 MPSTATUS MpStatus;
730
731 DPRINT("MiniportOpenEndpoint: Endpoint - %p\n", Endpoint);
732
733 FdoExtension = FdoDevice->DeviceExtension;
734 Packet = &FdoExtension->MiniPortInterface->Packet;
735
736 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
737
738 Endpoint->Flags &= ~ENDPOINT_FLAG_CLOSED;
739
740 MpStatus = Packet->OpenEndpoint(FdoExtension->MiniPortExt,
741 &Endpoint->EndpointProperties,
742 Endpoint + 1);
743
744 if (!MpStatus)
745 {
746 TransferType = Endpoint->EndpointProperties.TransferType;
747
748 if (TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT ||
749 TransferType == USBPORT_TRANSFER_TYPE_ISOCHRONOUS)
750 {
751 ++FdoExtension->PeriodicEndpoints;
752 }
753
754 Endpoint->Flags |= ENDPOINT_FLAG_OPENED;
755 }
756
757 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
758 return MpStatus;
759 }
760
761 NTSTATUS
762 NTAPI
763 USBPORT_OpenPipe(IN PDEVICE_OBJECT FdoDevice,
764 IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
765 IN PUSBPORT_PIPE_HANDLE PipeHandle,
766 IN OUT PUSBD_STATUS UsbdStatus)
767 {
768 PUSBPORT_DEVICE_EXTENSION FdoExtension;
769 PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
770 PUSBPORT_REGISTRATION_PACKET Packet;
771 ULONG EndpointSize;
772 PUSBPORT_ENDPOINT Endpoint;
773 PUSBPORT_ENDPOINT_PROPERTIES EndpointProperties;
774 PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor;
775 UCHAR Direction;
776 UCHAR Interval;
777 UCHAR Period;
778 USBPORT_ENDPOINT_REQUIREMENTS EndpointRequirements = {0};
779 PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer;
780 MPSTATUS MpStatus;
781 USBD_STATUS USBDStatus;
782 NTSTATUS Status;
783 KIRQL OldIrql;
784 USHORT MaxPacketSize;
785 USHORT AdditionalTransaction;
786 BOOLEAN IsAllocatedBandwidth;
787
788 DPRINT1("USBPORT_OpenPipe: DeviceHandle - %p, FdoDevice - %p, PipeHandle - %p\n",
789 DeviceHandle,
790 FdoDevice,
791 PipeHandle);
792
793 FdoExtension = FdoDevice->DeviceExtension;
794 Packet = &FdoExtension->MiniPortInterface->Packet;
795
796 EndpointSize = sizeof(USBPORT_ENDPOINT) + Packet->MiniPortEndpointSize;
797
798 if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
799 {
800 EndpointSize += sizeof(USB2_TT_ENDPOINT);
801 }
802
803 if (PipeHandle->EndpointDescriptor.wMaxPacketSize == 0)
804 {
805 USBPORT_AddPipeHandle(DeviceHandle, PipeHandle);
806
807 PipeHandle->Flags = (PipeHandle->Flags & ~PIPE_HANDLE_FLAG_CLOSED) |
808 PIPE_HANDLE_FLAG_NULL_PACKET_SIZE;
809
810 PipeHandle->Endpoint = (PUSBPORT_ENDPOINT)-1;
811
812 return STATUS_SUCCESS;
813 }
814
815 Endpoint = ExAllocatePoolWithTag(NonPagedPool, EndpointSize, USB_PORT_TAG);
816
817 if (!Endpoint)
818 {
819 DPRINT1("USBPORT_OpenPipe: Not allocated Endpoint!\n");
820 Status = STATUS_INSUFFICIENT_RESOURCES;
821 return Status;
822 }
823
824 RtlZeroMemory(Endpoint, EndpointSize);
825
826 Endpoint->FdoDevice = FdoDevice;
827 Endpoint->DeviceHandle = DeviceHandle;
828 Endpoint->LockCounter = -1;
829
830 Endpoint->TtExtension = DeviceHandle->TtExtension;
831
832 if (DeviceHandle->TtExtension)
833 {
834 ExInterlockedInsertTailList(&DeviceHandle->TtExtension->EndpointList,
835 &Endpoint->TtLink,
836 &FdoExtension->TtSpinLock);
837 }
838
839 if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
840 {
841 Endpoint->TtEndpoint = (PUSB2_TT_ENDPOINT)((ULONG_PTR)Endpoint +
842 sizeof(USBPORT_ENDPOINT) +
843 Packet->MiniPortEndpointSize);
844 }
845 else
846 {
847 Endpoint->TtEndpoint = NULL;
848 }
849
850 KeInitializeSpinLock(&Endpoint->EndpointSpinLock);
851 KeInitializeSpinLock(&Endpoint->StateChangeSpinLock);
852
853 InitializeListHead(&Endpoint->PendingTransferList);
854 InitializeListHead(&Endpoint->TransferList);
855 InitializeListHead(&Endpoint->CancelList);
856 InitializeListHead(&Endpoint->AbortList);
857
858 EndpointProperties = &Endpoint->EndpointProperties;
859 EndpointDescriptor = &PipeHandle->EndpointDescriptor;
860
861 MaxPacketSize = EndpointDescriptor->wMaxPacketSize & 0x7FF;
862 AdditionalTransaction = (EndpointDescriptor->wMaxPacketSize >> 11) & 3;
863
864 EndpointProperties->DeviceAddress = DeviceHandle->DeviceAddress;
865 EndpointProperties->DeviceSpeed = DeviceHandle->DeviceSpeed;
866 EndpointProperties->Period = 0;
867 EndpointProperties->EndpointAddress = EndpointDescriptor->bEndpointAddress;
868 EndpointProperties->TransactionPerMicroframe = AdditionalTransaction + 1;
869 EndpointProperties->MaxPacketSize = MaxPacketSize;
870 EndpointProperties->TotalMaxPacketSize = MaxPacketSize *
871 (AdditionalTransaction + 1);
872
873 if (Endpoint->TtExtension)
874 {
875 EndpointProperties->HubAddr = Endpoint->TtExtension->DeviceAddress;
876 }
877 else
878 {
879 EndpointProperties->HubAddr = -1;
880 }
881
882 EndpointProperties->PortNumber = DeviceHandle->PortNumber;
883
884 switch (EndpointDescriptor->bmAttributes & USB_ENDPOINT_TYPE_MASK)
885 {
886 case USB_ENDPOINT_TYPE_CONTROL:
887 EndpointProperties->TransferType = USBPORT_TRANSFER_TYPE_CONTROL;
888
889 if (EndpointProperties->EndpointAddress == 0)
890 {
891 EndpointProperties->MaxTransferSize = 0x1000; // OUT Ep0
892 }
893 else
894 {
895 EndpointProperties->MaxTransferSize = 0x10000;
896 }
897
898 break;
899
900 case USB_ENDPOINT_TYPE_ISOCHRONOUS:
901 DPRINT1("USBPORT_OpenPipe: USB_ENDPOINT_TYPE_ISOCHRONOUS UNIMPLEMENTED. FIXME. \n");
902 EndpointProperties->TransferType = USBPORT_TRANSFER_TYPE_ISOCHRONOUS;
903 EndpointProperties->MaxTransferSize = 0x1000000;
904 break;
905
906 case USB_ENDPOINT_TYPE_BULK:
907 EndpointProperties->TransferType = USBPORT_TRANSFER_TYPE_BULK;
908 EndpointProperties->MaxTransferSize = 0x10000;
909 break;
910
911 case USB_ENDPOINT_TYPE_INTERRUPT:
912 EndpointProperties->TransferType = USBPORT_TRANSFER_TYPE_INTERRUPT;
913 EndpointProperties->MaxTransferSize = 0x400;
914 break;
915 }
916
917 if (EndpointProperties->TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT)
918 {
919 if (EndpointProperties->DeviceSpeed == UsbHighSpeed)
920 {
921 Interval = USBPORT_NormalizeHsInterval(EndpointDescriptor->bInterval);
922 }
923 else
924 {
925 Interval = EndpointDescriptor->bInterval;
926 }
927
928 EndpointProperties->Period = ENDPOINT_INTERRUPT_32ms;
929
930 if (Interval && (Interval < USB2_FRAMES))
931 {
932 if ((EndpointProperties->DeviceSpeed != UsbLowSpeed) ||
933 (Interval >= ENDPOINT_INTERRUPT_8ms))
934 {
935 if (!(Interval & ENDPOINT_INTERRUPT_32ms))
936 {
937 Period = EndpointProperties->Period;
938
939 do
940 {
941 Period >>= 1;
942 }
943 while (!(Period & Interval));
944
945 EndpointProperties->Period = Period;
946 }
947 }
948 else
949 {
950 EndpointProperties->Period = ENDPOINT_INTERRUPT_8ms;
951 }
952 }
953 }
954
955 if (EndpointProperties->TransferType == USB_ENDPOINT_TYPE_ISOCHRONOUS)
956 {
957 if (EndpointProperties->DeviceSpeed == UsbHighSpeed)
958 {
959 EndpointProperties->Period =
960 USBPORT_NormalizeHsInterval(EndpointDescriptor->bInterval);
961 }
962 else
963 {
964 EndpointProperties->Period = ENDPOINT_INTERRUPT_1ms;
965 }
966 }
967
968 if ((DeviceHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB) != 0)
969 {
970 Endpoint->Flags |= ENDPOINT_FLAG_ROOTHUB_EP0;
971 }
972
973 if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
974 {
975 IsAllocatedBandwidth = USBPORT_AllocateBandwidthUSB2(FdoDevice, Endpoint);
976 }
977 else
978 {
979 EndpointProperties->UsbBandwidth = USBPORT_CalculateUsbBandwidth(FdoDevice,
980 Endpoint);
981
982 IsAllocatedBandwidth = USBPORT_AllocateBandwidth(FdoDevice, Endpoint);
983 }
984
985 if (!IsAllocatedBandwidth)
986 {
987 Status = USBPORT_USBDStatusToNtStatus(NULL, USBD_STATUS_NO_BANDWIDTH);
988
989 if (UsbdStatus)
990 {
991 *UsbdStatus = USBD_STATUS_NO_BANDWIDTH;
992 }
993
994 goto ExitWithError;
995 }
996
997 Direction = USB_ENDPOINT_DIRECTION_OUT(EndpointDescriptor->bEndpointAddress);
998 EndpointProperties->Direction = Direction;
999
1000 if (DeviceHandle->IsRootHub)
1001 {
1002 Endpoint->EndpointWorker = 0; // USBPORT_RootHubEndpointWorker;
1003
1004 Endpoint->Flags |= ENDPOINT_FLAG_ROOTHUB_EP0;
1005
1006 Endpoint->StateLast = USBPORT_ENDPOINT_ACTIVE;
1007 Endpoint->StateNext = USBPORT_ENDPOINT_ACTIVE;
1008
1009 PdoExtension = FdoExtension->RootHubPdo->DeviceExtension;
1010
1011 if (EndpointProperties->TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT)
1012 {
1013 PdoExtension->Endpoint = Endpoint;
1014 }
1015
1016 USBDStatus = USBD_STATUS_SUCCESS;
1017 }
1018 else
1019 {
1020 Endpoint->EndpointWorker = 1; // USBPORT_DmaEndpointWorker;
1021
1022 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
1023
1024 Packet->QueryEndpointRequirements(FdoExtension->MiniPortExt,
1025 &Endpoint->EndpointProperties,
1026 &EndpointRequirements);
1027
1028 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
1029
1030 if ((EndpointProperties->TransferType == USBPORT_TRANSFER_TYPE_BULK) ||
1031 (EndpointProperties->TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT))
1032 {
1033 EndpointProperties->MaxTransferSize = EndpointRequirements.MaxTransferSize;
1034 }
1035
1036 if (EndpointRequirements.HeaderBufferSize)
1037 {
1038 HeaderBuffer = USBPORT_AllocateCommonBuffer(FdoDevice,
1039 EndpointRequirements.HeaderBufferSize);
1040 }
1041 else
1042 {
1043 HeaderBuffer = NULL;
1044 }
1045
1046 if (HeaderBuffer || (EndpointRequirements.HeaderBufferSize == 0))
1047 {
1048 Endpoint->HeaderBuffer = HeaderBuffer;
1049
1050 if (HeaderBuffer)
1051 {
1052 EndpointProperties->BufferVA = HeaderBuffer->VirtualAddress;
1053 EndpointProperties->BufferPA = HeaderBuffer->PhysicalAddress;
1054 EndpointProperties->BufferLength = HeaderBuffer->BufferLength; // BufferLength + LengthPadded;
1055 }
1056
1057 MpStatus = MiniportOpenEndpoint(FdoDevice, Endpoint);
1058
1059 Endpoint->Flags |= ENDPOINT_FLAG_DMA_TYPE;
1060 Endpoint->Flags |= ENDPOINT_FLAG_QUEUENE_EMPTY;
1061
1062 if (MpStatus == 0)
1063 {
1064 ULONG State;
1065
1066 KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
1067 &Endpoint->EndpointOldIrql);
1068
1069 Endpoint->StateLast = USBPORT_ENDPOINT_PAUSED;
1070 Endpoint->StateNext = USBPORT_ENDPOINT_PAUSED;
1071
1072 USBPORT_SetEndpointState(Endpoint, USBPORT_ENDPOINT_ACTIVE);
1073
1074 KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
1075 Endpoint->EndpointOldIrql);
1076
1077 while (TRUE)
1078 {
1079 KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
1080 &Endpoint->EndpointOldIrql);
1081
1082 State = USBPORT_GetEndpointState(Endpoint);
1083
1084 KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
1085 Endpoint->EndpointOldIrql);
1086
1087 if (State == USBPORT_ENDPOINT_ACTIVE)
1088 {
1089 break;
1090 }
1091
1092 USBPORT_Wait(FdoDevice, 1); // 1 msec.
1093 }
1094 }
1095 }
1096 else
1097 {
1098 MpStatus = MP_STATUS_NO_RESOURCES;
1099 Endpoint->HeaderBuffer = NULL;
1100 }
1101
1102 if (MpStatus)
1103 {
1104 USBDStatus = USBD_STATUS_INSUFFICIENT_RESOURCES;
1105 }
1106 else
1107 {
1108 USBDStatus = USBD_STATUS_SUCCESS;
1109 }
1110 }
1111
1112 if (UsbdStatus)
1113 {
1114 *UsbdStatus = USBDStatus;
1115 }
1116
1117 Status = USBPORT_USBDStatusToNtStatus(NULL, USBDStatus);
1118
1119 if (NT_SUCCESS(Status))
1120 {
1121 USBPORT_AddPipeHandle(DeviceHandle, PipeHandle);
1122
1123 ExInterlockedInsertTailList(&FdoExtension->EndpointList,
1124 &Endpoint->EndpointLink,
1125 &FdoExtension->EndpointListSpinLock);
1126
1127 PipeHandle->Endpoint = Endpoint;
1128 PipeHandle->Flags &= ~PIPE_HANDLE_FLAG_CLOSED;
1129
1130 return Status;
1131 }
1132
1133 ExitWithError:
1134
1135 if (Endpoint)
1136 {
1137 if (IsAllocatedBandwidth)
1138 {
1139 if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
1140 {
1141 USBPORT_FreeBandwidthUSB2(FdoDevice, Endpoint);
1142 }
1143 else
1144 {
1145 USBPORT_FreeBandwidth(FdoDevice, Endpoint);
1146 }
1147 }
1148
1149 if (Endpoint->TtExtension)
1150 {
1151 KeAcquireSpinLock(&FdoExtension->TtSpinLock, &OldIrql);
1152 RemoveEntryList(&Endpoint->TtLink);
1153 KeReleaseSpinLock(&FdoExtension->TtSpinLock, OldIrql);
1154 }
1155
1156 ExFreePoolWithTag(Endpoint, USB_PORT_TAG);
1157 }
1158
1159 DPRINT1("USBPORT_OpenPipe: Status - %lx\n", Status);
1160 return Status;
1161 }
1162
1163 NTSTATUS
1164 NTAPI
1165 USBPORT_ReopenPipe(IN PDEVICE_OBJECT FdoDevice,
1166 IN PUSBPORT_ENDPOINT Endpoint)
1167 {
1168 PUSBPORT_DEVICE_EXTENSION FdoExtension;
1169 PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer;
1170 USBPORT_ENDPOINT_REQUIREMENTS EndpointRequirements = {0};
1171 PUSBPORT_REGISTRATION_PACKET Packet;
1172 KIRQL MiniportOldIrql;
1173 NTSTATUS Status;
1174
1175 DPRINT1("USBPORT_ReopenPipe ... \n");
1176
1177 FdoExtension = FdoDevice->DeviceExtension;
1178 Packet = &FdoExtension->MiniPortInterface->Packet;
1179
1180 while (TRUE)
1181 {
1182 if (!InterlockedIncrement(&Endpoint->LockCounter))
1183 break;
1184
1185 InterlockedDecrement(&Endpoint->LockCounter);
1186 USBPORT_Wait(FdoDevice, 1);
1187 }
1188
1189 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &MiniportOldIrql);
1190
1191 Packet->SetEndpointState(FdoExtension->MiniPortExt,
1192 Endpoint + 1,
1193 USBPORT_ENDPOINT_REMOVE);
1194
1195 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, MiniportOldIrql);
1196
1197 USBPORT_Wait(FdoDevice, 2);
1198
1199 MiniportCloseEndpoint(FdoDevice, Endpoint);
1200
1201 RtlZeroMemory(Endpoint + 1,
1202 Packet->MiniPortEndpointSize);
1203
1204 if (Endpoint->HeaderBuffer)
1205 {
1206 USBPORT_FreeCommonBuffer(FdoDevice, Endpoint->HeaderBuffer);
1207 Endpoint->HeaderBuffer = NULL;
1208 }
1209
1210 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &MiniportOldIrql);
1211
1212 Packet->QueryEndpointRequirements(FdoExtension->MiniPortExt,
1213 &Endpoint->EndpointProperties,
1214 &EndpointRequirements);
1215
1216 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, MiniportOldIrql);
1217
1218 if (EndpointRequirements.HeaderBufferSize)
1219 {
1220 HeaderBuffer = USBPORT_AllocateCommonBuffer(FdoDevice,
1221 EndpointRequirements.HeaderBufferSize);
1222 }
1223 else
1224 {
1225 HeaderBuffer = NULL;
1226 }
1227
1228 if (HeaderBuffer || EndpointRequirements.HeaderBufferSize == 0)
1229 {
1230 Endpoint->HeaderBuffer = HeaderBuffer;
1231 Status = STATUS_SUCCESS;
1232 }
1233 else
1234 {
1235 Endpoint->HeaderBuffer = 0;
1236 Status = STATUS_INSUFFICIENT_RESOURCES;
1237 }
1238
1239 if (Endpoint->HeaderBuffer && HeaderBuffer)
1240 {
1241 Endpoint->EndpointProperties.BufferVA = HeaderBuffer->VirtualAddress;
1242 Endpoint->EndpointProperties.BufferPA = HeaderBuffer->PhysicalAddress;
1243 Endpoint->EndpointProperties.BufferLength = HeaderBuffer->BufferLength;
1244 }
1245
1246 if (NT_SUCCESS(Status))
1247 {
1248 MiniportOpenEndpoint(FdoDevice, Endpoint);
1249
1250 KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
1251 KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
1252
1253 if (Endpoint->StateLast == USBPORT_ENDPOINT_ACTIVE)
1254 {
1255 KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportSpinLock);
1256
1257 Packet->SetEndpointState(FdoExtension->MiniPortExt,
1258 Endpoint + 1,
1259 USBPORT_ENDPOINT_ACTIVE);
1260
1261 KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportSpinLock);
1262 }
1263
1264 KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
1265 KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
1266 }
1267
1268 InterlockedDecrement(&Endpoint->LockCounter);
1269
1270 return Status;
1271 }
1272
1273 VOID
1274 NTAPI
1275 USBPORT_FlushClosedEndpointList(IN PDEVICE_OBJECT FdoDevice)
1276 {
1277 PUSBPORT_DEVICE_EXTENSION FdoExtension;
1278 KIRQL OldIrql;
1279 PLIST_ENTRY ClosedList;
1280 PUSBPORT_ENDPOINT Endpoint;
1281
1282 DPRINT("USBPORT_FlushClosedEndpointList: ... \n");
1283
1284 FdoExtension = FdoDevice->DeviceExtension;
1285
1286 KeAcquireSpinLock(&FdoExtension->EndpointClosedSpinLock, &OldIrql);
1287 ClosedList = &FdoExtension->EndpointClosedList;
1288
1289 while (!IsListEmpty(ClosedList))
1290 {
1291 Endpoint = CONTAINING_RECORD(ClosedList->Flink,
1292 USBPORT_ENDPOINT,
1293 CloseLink);
1294
1295 RemoveHeadList(ClosedList);
1296 Endpoint->CloseLink.Flink = NULL;
1297 Endpoint->CloseLink.Blink = NULL;
1298
1299 KeReleaseSpinLock(&FdoExtension->EndpointClosedSpinLock, OldIrql);
1300
1301 USBPORT_DeleteEndpoint(FdoDevice, Endpoint);
1302
1303 KeAcquireSpinLock(&FdoExtension->EndpointClosedSpinLock, &OldIrql);
1304 }
1305
1306 KeReleaseSpinLock(&FdoExtension->EndpointClosedSpinLock, OldIrql);
1307 }
1308
1309 VOID
1310 NTAPI
1311 USBPORT_InvalidateEndpointHandler(IN PDEVICE_OBJECT FdoDevice,
1312 IN PUSBPORT_ENDPOINT Endpoint,
1313 IN ULONG Type)
1314 {
1315 PUSBPORT_DEVICE_EXTENSION FdoExtension;
1316 PUSBPORT_REGISTRATION_PACKET Packet;
1317 PLIST_ENTRY Entry;
1318 PLIST_ENTRY WorkerLink;
1319 PUSBPORT_ENDPOINT endpoint;
1320 KIRQL OldIrql;
1321 BOOLEAN IsAddEntry = FALSE;
1322
1323 DPRINT_CORE("USBPORT_InvalidateEndpointHandler: Endpoint - %p, Type - %x\n",
1324 Endpoint,
1325 Type);
1326
1327 FdoExtension = FdoDevice->DeviceExtension;
1328 Packet = &FdoExtension->MiniPortInterface->Packet;
1329
1330 if (Endpoint)
1331 {
1332 WorkerLink = &Endpoint->WorkerLink;
1333 KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
1334 DPRINT_CORE("USBPORT_InvalidateEndpointHandler: KeAcquireSpinLock \n");
1335
1336 if ((!WorkerLink->Flink || !WorkerLink->Blink) &&
1337 !(Endpoint->Flags & ENDPOINT_FLAG_IDLE) &&
1338 USBPORT_GetEndpointState(Endpoint) != USBPORT_ENDPOINT_CLOSED)
1339 {
1340 DPRINT_CORE("USBPORT_InvalidateEndpointHandler: InsertTailList \n");
1341 InsertTailList(&FdoExtension->WorkerList, WorkerLink);
1342 IsAddEntry = TRUE;
1343 }
1344
1345 KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
1346
1347 if (Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0)
1348 Type = INVALIDATE_ENDPOINT_WORKER_THREAD;
1349 }
1350 else
1351 {
1352 KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
1353
1354 Entry = &FdoExtension->EndpointList;
1355
1356 while (Entry && Entry != &FdoExtension->EndpointList)
1357 {
1358 endpoint = CONTAINING_RECORD(Entry,
1359 USBPORT_ENDPOINT,
1360 EndpointLink);
1361
1362 if (!endpoint->WorkerLink.Flink || !endpoint->WorkerLink.Blink)
1363 {
1364 if (!(endpoint->Flags & ENDPOINT_FLAG_IDLE) &&
1365 !(endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0) &&
1366 USBPORT_GetEndpointState(endpoint) != USBPORT_ENDPOINT_CLOSED)
1367 {
1368 DPRINT_CORE("USBPORT_InvalidateEndpointHandler: InsertTailList \n");
1369 InsertTailList(&FdoExtension->WorkerList, &endpoint->WorkerLink);
1370 IsAddEntry = TRUE;
1371 }
1372 }
1373
1374 Entry = endpoint->EndpointLink.Flink;
1375 }
1376
1377 KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
1378 }
1379
1380 if (FdoExtension->Flags & USBPORT_FLAG_HC_SUSPEND)
1381 {
1382 Type = INVALIDATE_ENDPOINT_WORKER_THREAD;
1383 }
1384 else if (IsAddEntry == FALSE && Type == INVALIDATE_ENDPOINT_INT_NEXT_SOF)
1385 {
1386 Type = INVALIDATE_ENDPOINT_ONLY;
1387 }
1388
1389 switch (Type)
1390 {
1391 case INVALIDATE_ENDPOINT_WORKER_THREAD:
1392 USBPORT_SignalWorkerThread(FdoDevice);
1393 break;
1394
1395 case INVALIDATE_ENDPOINT_WORKER_DPC:
1396 KeInsertQueueDpc(&FdoExtension->WorkerRequestDpc, NULL, NULL);
1397 break;
1398
1399 case INVALIDATE_ENDPOINT_INT_NEXT_SOF:
1400 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
1401 Packet->InterruptNextSOF(FdoExtension->MiniPortExt);
1402 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
1403 break;
1404 }
1405 }
1406
1407 ULONG
1408 NTAPI
1409 USBPORT_DmaEndpointPaused(IN PDEVICE_OBJECT FdoDevice,
1410 IN PUSBPORT_ENDPOINT Endpoint)
1411 {
1412 PUSBPORT_DEVICE_EXTENSION FdoExtension;
1413 PUSBPORT_REGISTRATION_PACKET Packet;
1414 PLIST_ENTRY Entry;
1415 PUSBPORT_TRANSFER Transfer;
1416 PURB Urb;
1417 ULONG Frame;
1418 ULONG CurrentFrame;
1419 ULONG CompletedLen = 0;
1420 KIRQL OldIrql;
1421
1422 DPRINT_CORE("USBPORT_DmaEndpointPaused \n");
1423
1424 FdoExtension = FdoDevice->DeviceExtension;
1425 Packet = &FdoExtension->MiniPortInterface->Packet;
1426
1427 Entry = Endpoint->TransferList.Flink;
1428
1429 if (Entry == &Endpoint->TransferList)
1430 return USBPORT_ENDPOINT_ACTIVE;
1431
1432 while (Entry && Entry != &Endpoint->TransferList)
1433 {
1434 Transfer = CONTAINING_RECORD(Entry,
1435 USBPORT_TRANSFER,
1436 TransferLink);
1437
1438 if (Transfer->Flags & (TRANSFER_FLAG_CANCELED | TRANSFER_FLAG_ABORTED))
1439 {
1440 if (Transfer->Flags & TRANSFER_FLAG_ISO &&
1441 Transfer->Flags & TRANSFER_FLAG_SUBMITED &&
1442 !(Endpoint->Flags & ENDPOINT_FLAG_NUKE))
1443 {
1444 Urb = Transfer->Urb;
1445
1446 Frame = Urb->UrbIsochronousTransfer.StartFrame +
1447 Urb->UrbIsochronousTransfer.NumberOfPackets;
1448
1449 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
1450 CurrentFrame = Packet->Get32BitFrameNumber(FdoExtension->MiniPortExt);
1451 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
1452
1453 if (Frame + 1 > CurrentFrame)
1454 {
1455 return USBPORT_GetEndpointState(Endpoint);
1456 }
1457 }
1458
1459 if ((Transfer->Flags & TRANSFER_FLAG_SUBMITED) &&
1460 !(Endpoint->Flags & ENDPOINT_FLAG_NUKE))
1461 {
1462 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
1463
1464 Packet->AbortTransfer(FdoExtension->MiniPortExt,
1465 Endpoint + 1,
1466 Transfer->MiniportTransfer,
1467 &CompletedLen);
1468
1469 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
1470
1471 if (Transfer->Flags & TRANSFER_FLAG_ISO)
1472 {
1473 DPRINT1("USBPORT_DmaEndpointActive: FIXME call USBPORT_FlushIsoTransfer\n");
1474 ASSERT(FALSE); //USBPORT_FlushIsoTransfer();
1475 }
1476 else
1477 {
1478 Transfer->CompletedTransferLen = CompletedLen;
1479 }
1480 }
1481
1482 RemoveEntryList(&Transfer->TransferLink);
1483 Entry = Transfer->TransferLink.Flink;
1484
1485 if (Transfer->Flags & TRANSFER_FLAG_SPLITED)
1486 {
1487 USBPORT_CancelSplitTransfer(Transfer);
1488 }
1489 else
1490 {
1491 InsertTailList(&Endpoint->CancelList, &Transfer->TransferLink);
1492 }
1493 }
1494 else
1495 {
1496 Entry = Transfer->TransferLink.Flink;
1497 }
1498 }
1499
1500 return USBPORT_ENDPOINT_ACTIVE;
1501 }
1502
1503 ULONG
1504 NTAPI
1505 USBPORT_DmaEndpointActive(IN PDEVICE_OBJECT FdoDevice,
1506 IN PUSBPORT_ENDPOINT Endpoint)
1507 {
1508 PUSBPORT_DEVICE_EXTENSION FdoExtension;
1509 PUSBPORT_REGISTRATION_PACKET Packet;
1510 PLIST_ENTRY Entry;
1511 PUSBPORT_TRANSFER Transfer;
1512 LARGE_INTEGER TimeOut;
1513 MPSTATUS MpStatus;
1514 KIRQL OldIrql;
1515
1516 DPRINT_CORE("USBPORT_DmaEndpointActive \n");
1517
1518 FdoExtension = FdoDevice->DeviceExtension;
1519
1520 Entry = Endpoint->TransferList.Flink;
1521
1522 while (Entry && Entry != &Endpoint->TransferList)
1523 {
1524 Transfer = CONTAINING_RECORD(Entry,
1525 USBPORT_TRANSFER,
1526 TransferLink);
1527
1528 if (!(Transfer->Flags & TRANSFER_FLAG_SUBMITED) &&
1529 !(Endpoint->Flags & ENDPOINT_FLAG_NUKE))
1530 {
1531 KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
1532
1533 Packet = &FdoExtension->MiniPortInterface->Packet;
1534
1535 if (Transfer->Flags & TRANSFER_FLAG_ISO)
1536 {
1537 DPRINT1("USBPORT_DmaEndpointActive: FIXME call SubmitIsoTransfer\n");
1538
1539 MpStatus = Packet->SubmitIsoTransfer(FdoExtension->MiniPortExt,
1540 Endpoint + 1,
1541 &Transfer->TransferParameters,
1542 Transfer->MiniportTransfer,
1543 NULL);//&Transfer->IsoTransferParameters);
1544 }
1545 else
1546 {
1547 MpStatus = Packet->SubmitTransfer(FdoExtension->MiniPortExt,
1548 Endpoint + 1,
1549 &Transfer->TransferParameters,
1550 Transfer->MiniportTransfer,
1551 &Transfer->SgList);
1552 }
1553
1554 KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
1555
1556 if (MpStatus)
1557 {
1558 if ((MpStatus != MP_STATUS_FAILURE) && Transfer->Flags & TRANSFER_FLAG_ISO)
1559 {
1560 DPRINT1("USBPORT_DmaEndpointActive: FIXME call USBPORT_ErrorCompleteIsoTransfer\n");
1561 ASSERT(FALSE); //USBPORT_ErrorCompleteIsoTransfer();
1562 }
1563
1564 return USBPORT_ENDPOINT_ACTIVE;
1565 }
1566
1567 Transfer->Flags |= TRANSFER_FLAG_SUBMITED;
1568 KeQuerySystemTime(&Transfer->Time);
1569
1570 TimeOut.QuadPart = 10000 * Transfer->TimeOut;
1571 Transfer->Time.QuadPart += TimeOut.QuadPart;
1572 }
1573
1574 if (Transfer->Flags & (TRANSFER_FLAG_CANCELED | TRANSFER_FLAG_ABORTED))
1575 {
1576 return USBPORT_ENDPOINT_PAUSED;
1577 }
1578
1579 Entry = Transfer->TransferLink.Flink;
1580 }
1581
1582 return USBPORT_ENDPOINT_ACTIVE;
1583 }
1584
1585 VOID
1586 NTAPI
1587 USBPORT_DmaEndpointWorker(IN PUSBPORT_ENDPOINT Endpoint)
1588 {
1589 PDEVICE_OBJECT FdoDevice;
1590 ULONG PrevState;
1591 ULONG EndpointState;
1592 BOOLEAN IsPaused = FALSE;
1593
1594 DPRINT_CORE("USBPORT_DmaEndpointWorker ... \n");
1595
1596 FdoDevice = Endpoint->FdoDevice;
1597
1598 KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
1599
1600 PrevState = USBPORT_GetEndpointState(Endpoint);
1601
1602 if (PrevState == USBPORT_ENDPOINT_PAUSED)
1603 {
1604 EndpointState = USBPORT_DmaEndpointPaused(FdoDevice, Endpoint);
1605 }
1606 else if (PrevState == USBPORT_ENDPOINT_ACTIVE)
1607 {
1608 EndpointState = USBPORT_DmaEndpointActive(FdoDevice, Endpoint);
1609 }
1610 else
1611 {
1612 #ifndef NDEBUG_USBPORT_CORE
1613 DPRINT1("USBPORT_DmaEndpointWorker: DbgBreakPoint. EndpointState - %x\n",
1614 EndpointState);
1615 DbgBreakPoint();
1616 #endif
1617 EndpointState = USBPORT_ENDPOINT_UNKNOWN;
1618 }
1619
1620 KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
1621
1622 USBPORT_FlushCancelList(Endpoint);
1623
1624 KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
1625
1626 if (EndpointState == PrevState)
1627 {
1628 if (EndpointState == USBPORT_ENDPOINT_PAUSED)
1629 {
1630 IsPaused = TRUE;
1631 }
1632 }
1633 else
1634 {
1635 USBPORT_SetEndpointState(Endpoint, EndpointState);
1636 }
1637
1638 KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
1639
1640 if (IsPaused)
1641 {
1642 USBPORT_InvalidateEndpointHandler(FdoDevice,
1643 Endpoint,
1644 INVALIDATE_ENDPOINT_WORKER_THREAD);
1645 }
1646
1647 DPRINT_CORE("USBPORT_DmaEndpointWorker exit \n");
1648 }
1649
1650 BOOLEAN
1651 NTAPI
1652 USBPORT_EndpointWorker(IN PUSBPORT_ENDPOINT Endpoint,
1653 IN BOOLEAN LockNotChecked)
1654 {
1655 PDEVICE_OBJECT FdoDevice;
1656 PUSBPORT_DEVICE_EXTENSION FdoExtension;
1657 PUSBPORT_REGISTRATION_PACKET Packet;
1658 ULONG EndpointState;
1659
1660 DPRINT_CORE("USBPORT_EndpointWorker: Endpoint - %p, LockNotChecked - %x\n",
1661 Endpoint,
1662 LockNotChecked);
1663
1664 FdoDevice = Endpoint->FdoDevice;
1665 FdoExtension = FdoDevice->DeviceExtension;
1666 Packet = &FdoExtension->MiniPortInterface->Packet;
1667
1668 if (LockNotChecked == FALSE)
1669 {
1670 if (InterlockedIncrement(&Endpoint->LockCounter))
1671 {
1672 InterlockedDecrement(&Endpoint->LockCounter);
1673 DPRINT_CORE("USBPORT_EndpointWorker: LockCounter > 0\n");
1674 return TRUE;
1675 }
1676 }
1677
1678 ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
1679
1680 KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
1681
1682 if (USBPORT_GetEndpointState(Endpoint) == USBPORT_ENDPOINT_CLOSED)
1683 {
1684 KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
1685 InterlockedDecrement(&Endpoint->LockCounter);
1686 DPRINT_CORE("USBPORT_EndpointWorker: State == USBPORT_ENDPOINT_CLOSED. return FALSE\n");
1687 return FALSE;
1688 }
1689
1690 if ((Endpoint->Flags & (ENDPOINT_FLAG_ROOTHUB_EP0 | ENDPOINT_FLAG_NUKE)) == 0)
1691 {
1692 KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportSpinLock);
1693 Packet->PollEndpoint(FdoExtension->MiniPortExt, Endpoint + 1);
1694 KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportSpinLock);
1695 }
1696
1697 EndpointState = USBPORT_GetEndpointState(Endpoint);
1698
1699 if (EndpointState == USBPORT_ENDPOINT_REMOVE)
1700 {
1701 KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
1702 Endpoint->StateLast = USBPORT_ENDPOINT_CLOSED;
1703 Endpoint->StateNext = USBPORT_ENDPOINT_CLOSED;
1704 KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
1705
1706 KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
1707
1708 KeAcquireSpinLockAtDpcLevel(&FdoExtension->EndpointListSpinLock);
1709
1710 ExInterlockedInsertTailList(&FdoExtension->EndpointClosedList,
1711 &Endpoint->CloseLink,
1712 &FdoExtension->EndpointClosedSpinLock);
1713
1714 KeReleaseSpinLockFromDpcLevel(&FdoExtension->EndpointListSpinLock);
1715
1716 InterlockedDecrement(&Endpoint->LockCounter);
1717 DPRINT_CORE("USBPORT_EndpointWorker: State == USBPORT_ENDPOINT_REMOVE. return FALSE\n");
1718 return FALSE;
1719 }
1720
1721 if (!IsListEmpty(&Endpoint->PendingTransferList) ||
1722 !IsListEmpty(&Endpoint->TransferList) ||
1723 !IsListEmpty(&Endpoint->CancelList))
1724 {
1725 KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
1726
1727 EndpointState = USBPORT_GetEndpointState(Endpoint);
1728
1729 KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
1730 if (EndpointState == Endpoint->StateNext)
1731 {
1732 KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
1733
1734 if (Endpoint->EndpointWorker)
1735 {
1736 USBPORT_DmaEndpointWorker(Endpoint);
1737 }
1738 else
1739 {
1740 USBPORT_RootHubEndpointWorker(Endpoint);
1741 }
1742
1743 USBPORT_FlushAbortList(Endpoint);
1744
1745 InterlockedDecrement(&Endpoint->LockCounter);
1746 DPRINT_CORE("USBPORT_EndpointWorker: return FALSE\n");
1747 return FALSE;
1748 }
1749
1750 KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
1751 InterlockedDecrement(&Endpoint->LockCounter);
1752
1753 DPRINT_CORE("USBPORT_EndpointWorker: return TRUE\n");
1754 return TRUE;
1755 }
1756
1757 KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
1758
1759 USBPORT_FlushAbortList(Endpoint);
1760
1761 InterlockedDecrement(&Endpoint->LockCounter);
1762 DPRINT_CORE("USBPORT_EndpointWorker: return FALSE\n");
1763 return FALSE;
1764 }