a7936b2e7148b37b52235e7e7035c494d166eb59
[reactos.git] / drivers / usb / usbehci_new / usb_queue.cpp
1 /*
2 * PROJECT: ReactOS Universal Serial Bus Bulk Enhanced Host Controller Interface
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: drivers/usb/usbehci/usb_queue.cpp
5 * PURPOSE: USB EHCI device driver.
6 * PROGRAMMERS:
7 * Michael Martin (michael.martin@reactos.org)
8 * Johannes Anderwald (johannes.anderwald@reactos.org)
9 */
10
11 #include "usbehci.h"
12 #include "hardware.h"
13
14 class CUSBQueue : public IUSBQueue
15 {
16 public:
17 STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
18
19 STDMETHODIMP_(ULONG) AddRef()
20 {
21 InterlockedIncrement(&m_Ref);
22 return m_Ref;
23 }
24 STDMETHODIMP_(ULONG) Release()
25 {
26 InterlockedDecrement(&m_Ref);
27
28 if (!m_Ref)
29 {
30 delete this;
31 return 0;
32 }
33 return m_Ref;
34 }
35
36 virtual NTSTATUS Initialize(IN PUSBHARDWAREDEVICE Hardware, PDMA_ADAPTER AdapterObject, IN PDMAMEMORYMANAGER MemManager, IN OPTIONAL PKSPIN_LOCK Lock);
37 virtual ULONG GetPendingRequestCount();
38 virtual NTSTATUS AddUSBRequest(PURB Urb);
39 virtual NTSTATUS AddUSBRequest(IUSBRequest * Request);
40 virtual NTSTATUS CancelRequests();
41 virtual NTSTATUS CreateUSBRequest(IUSBRequest **OutRequest);
42 virtual VOID InterruptCallback(IN NTSTATUS Status, OUT PULONG ShouldRingDoorBell);
43 virtual VOID CompleteAsyncRequests();
44
45 // constructor / destructor
46 CUSBQueue(IUnknown *OuterUnknown){}
47 virtual ~CUSBQueue(){}
48
49 protected:
50 LONG m_Ref; // reference count
51 KSPIN_LOCK m_Lock; // list lock
52 PDMA_ADAPTER m_Adapter; // dma adapter
53 PUSBHARDWAREDEVICE m_Hardware; // stores hardware object
54 PQUEUE_HEAD AsyncListQueueHead; // async queue head
55 LIST_ENTRY m_CompletedRequestAsyncList; // completed async request list
56 LIST_ENTRY m_PendingRequestAsyncList; // pending async request list
57 ULONG m_MaxPeriodicListEntries; // max perdiodic list entries
58 ULONG m_MaxPollingInterval; // max polling interval
59 PHYSICAL_ADDRESS m_SyncFrameListAddr; // physical address of sync frame list
60 PULONG m_SyncFrameList; // virtual address of sync frame list
61 PQUEUE_HEAD * m_SyncFrameListQueueHeads; // stores the frame list of queue head
62
63 // queue head manipulation functions
64 VOID LinkQueueHead(PQUEUE_HEAD HeadQueueHead, PQUEUE_HEAD NewQueueHead);
65 VOID UnlinkQueueHead(PQUEUE_HEAD QueueHead);
66 VOID LinkQueueHeadChain(PQUEUE_HEAD HeadQueueHead, PQUEUE_HEAD NewQueueHead);
67 PQUEUE_HEAD UnlinkQueueHeadChain(PQUEUE_HEAD HeadQueueHead, ULONG Count);
68
69 // processes the async list
70 VOID ProcessAsyncList(IN NTSTATUS Status, OUT PULONG ShouldRingDoorBell);
71
72 // called for each completed queue head
73 VOID QueueHeadCompletion(PQUEUE_HEAD QueueHead, NTSTATUS Status);
74
75 // called when the completion queue is cleaned up
76 VOID QueueHeadCleanup(PQUEUE_HEAD QueueHead);
77
78 // intializes the sync schedule
79 NTSTATUS InitializeSyncSchedule(IN PUSBHARDWAREDEVICE Hardware, IN PDMAMEMORYMANAGER MemManager);
80 };
81
82 //=================================================================================================
83 // COM
84 //
85 NTSTATUS
86 STDMETHODCALLTYPE
87 CUSBQueue::QueryInterface(
88 IN REFIID refiid,
89 OUT PVOID* Output)
90 {
91 if (IsEqualGUIDAligned(refiid, IID_IUnknown))
92 {
93 *Output = PVOID(PUNKNOWN(this));
94 PUNKNOWN(*Output)->AddRef();
95 return STATUS_SUCCESS;
96 }
97
98 return STATUS_UNSUCCESSFUL;
99 }
100
101 NTSTATUS
102 CUSBQueue::Initialize(
103 IN PUSBHARDWAREDEVICE Hardware,
104 IN PDMA_ADAPTER AdapterObject,
105 IN PDMAMEMORYMANAGER MemManager,
106 IN OPTIONAL PKSPIN_LOCK Lock)
107 {
108 NTSTATUS Status = STATUS_SUCCESS;
109
110 DPRINT("CUSBQueue::Initialize()\n");
111
112 ASSERT(Hardware);
113
114 //
115 // initialize device lock
116 //
117 KeInitializeSpinLock(&m_Lock);
118
119 //
120 // Get the AsyncQueueHead
121 //
122 AsyncListQueueHead = (PQUEUE_HEAD)Hardware->GetAsyncListQueueHead();
123
124 //
125 // Initialize the List Head
126 //
127 InitializeListHead(&AsyncListQueueHead->LinkedQueueHeads);
128
129 //
130 // Initialize completed async list head
131 //
132 InitializeListHead(&m_CompletedRequestAsyncList);
133
134 //
135 // Initialize pending async list head
136 //
137 InitializeListHead(&m_PendingRequestAsyncList);
138
139 //
140 // now initialize sync schedule
141 //
142 Status = InitializeSyncSchedule(Hardware, MemManager);
143
144 return Status;
145 }
146
147 NTSTATUS
148 CUSBQueue::InitializeSyncSchedule(
149 IN PUSBHARDWAREDEVICE Hardware,
150 IN PDMAMEMORYMANAGER MemManager)
151 {
152 PHYSICAL_ADDRESS QueueHeadPhysAddr;
153 NTSTATUS Status;
154 ULONG Index;
155 PQUEUE_HEAD QueueHead;
156
157 //
158 // FIXME: check if smaller list sizes are supported
159 //
160 m_MaxPeriodicListEntries = 1024;
161
162 //
163 // use polling scheme of 32ms
164 //
165 m_MaxPollingInterval = 32;
166
167 //
168 // allocate dummy frame list array
169 //
170 m_SyncFrameListQueueHeads = (PQUEUE_HEAD*)ExAllocatePool(NonPagedPool, m_MaxPollingInterval * sizeof(PQUEUE_HEAD));
171 if (!m_SyncFrameListQueueHeads)
172 {
173 //
174 // no memory
175 //
176 return STATUS_INSUFFICIENT_RESOURCES;
177 }
178
179
180 //
181 // first allocate a page to hold the queue array
182 //
183 Status = MemManager->Allocate(m_MaxPeriodicListEntries * sizeof(PVOID), (PVOID*)&m_SyncFrameList, &m_SyncFrameListAddr);
184 if (!NT_SUCCESS(Status))
185 {
186 //
187 // failed to allocate sync frame list array
188 //
189 DPRINT1("Failed to allocate sync frame list\n");
190 ExFreePool(m_SyncFrameListQueueHeads);
191 ASSERT(FALSE);
192 return STATUS_INSUFFICIENT_RESOURCES;
193 }
194
195 //
196 // now allocate queue head descriptors for the polling interval
197 //
198 for(Index = 0; Index < m_MaxPeriodicListEntries; Index++)
199 {
200 //
201 // check if is inside our polling interrupt frequency window
202 //
203 if (Index < m_MaxPollingInterval)
204 {
205 //
206 // allocate queue head
207 //
208 Status = MemManager->Allocate(sizeof(QUEUE_HEAD), (PVOID*)&QueueHead, &QueueHeadPhysAddr);
209
210 //
211 // initialize queue head
212 //
213 QueueHead->HorizontalLinkPointer = TERMINATE_POINTER;
214 QueueHead->AlternateNextPointer = TERMINATE_POINTER;
215 QueueHead->NextPointer = TERMINATE_POINTER;
216
217 //
218 // 1 for non high speed, 0 for high speed device
219 //
220 QueueHead->EndPointCharacteristics.ControlEndPointFlag = 0;
221 QueueHead->EndPointCharacteristics.HeadOfReclamation = FALSE;
222 QueueHead->EndPointCharacteristics.MaximumPacketLength = 64;
223
224 //
225 // Set NakCountReload to max value possible
226 //
227 QueueHead->EndPointCharacteristics.NakCountReload = 0xF;
228
229 //
230 // Get the Initial Data Toggle from the QEDT
231 //
232 QueueHead->EndPointCharacteristics.QEDTDataToggleControl = FALSE;
233
234 //
235 // FIXME: check if High Speed Device
236 //
237 QueueHead->EndPointCharacteristics.EndPointSpeed = QH_ENDPOINT_HIGHSPEED;
238 QueueHead->EndPointCapabilities.NumberOfTransactionPerFrame = 0x03;
239 QueueHead->Token.DWord = 0;
240 QueueHead->Token.Bits.InterruptOnComplete = FALSE;
241 QueueHead->PhysicalAddr = QueueHeadPhysAddr.LowPart;
242
243
244 //
245 // store in queue head array
246 //
247 m_SyncFrameListQueueHeads[Index] = QueueHead;
248 }
249 else
250 {
251 //
252 // get cached entry
253 //
254 QueueHead = m_SyncFrameListQueueHeads[m_MaxPeriodicListEntries % m_MaxPollingInterval];
255 }
256
257 //
258 // store entry
259 //
260 m_SyncFrameList[Index] = (QueueHead->PhysicalAddr | 0x2);
261 }
262
263 //
264 // now set the sync base
265 //
266 Hardware->SetPeriodicListRegister(m_SyncFrameListAddr.LowPart);
267
268 //
269 // sync frame list initialized
270 //
271 return STATUS_SUCCESS;
272 }
273
274 ULONG
275 CUSBQueue::GetPendingRequestCount()
276 {
277 //
278 // Loop through the pending list and iterrate one for each QueueHead that
279 // has a IRP to complete.
280 //
281
282 return 0;
283 }
284
285 NTSTATUS
286 CUSBQueue::AddUSBRequest(
287 IUSBRequest * Request)
288 {
289 PQUEUE_HEAD QueueHead;
290 NTSTATUS Status;
291 ULONG Type;
292 KIRQL OldLevel;
293
294 //
295 // sanity check
296 //
297 ASSERT(Request != NULL);
298
299 //
300 // get request type
301 //
302 Type = Request->GetTransferType();
303
304 //
305 // check if supported
306 //
307 switch(Type)
308 {
309 case USB_ENDPOINT_TYPE_ISOCHRONOUS:
310 case USB_ENDPOINT_TYPE_INTERRUPT:
311 /* NOT IMPLEMENTED IN QUEUE */
312 Status = STATUS_NOT_SUPPORTED;
313 break;
314 case USB_ENDPOINT_TYPE_BULK:
315 case USB_ENDPOINT_TYPE_CONTROL:
316 Status = STATUS_SUCCESS;
317 break;
318 default:
319 /* BUG */
320 PC_ASSERT(FALSE);
321 Status = STATUS_NOT_SUPPORTED;
322 }
323
324 //
325 // check for success
326 //
327 if (!NT_SUCCESS(Status))
328 {
329 //
330 // request not supported, please try later
331 //
332 return Status;
333 }
334
335 if (Type == USB_ENDPOINT_TYPE_BULK || Type == USB_ENDPOINT_TYPE_CONTROL)
336 {
337 //
338 // get queue head
339 //
340 Status = Request->GetQueueHead(&QueueHead);
341
342 //
343 // check for success
344 //
345 if (!NT_SUCCESS(Status))
346 {
347 //
348 // failed to get queue head
349 //
350 return Status;
351 }
352
353 DPRINT("Request %p QueueHead %p inserted into AsyncQueue\n", Request, QueueHead);
354
355 //
356 // Add it to the pending list
357 //
358 KeAcquireSpinLock(&m_Lock, &OldLevel);
359 LinkQueueHead(AsyncListQueueHead, QueueHead);
360 KeReleaseSpinLock(&m_Lock, OldLevel);
361 }
362
363
364 //
365 // add extra reference which is released when the request is completed
366 //
367 Request->AddRef();
368
369
370 return STATUS_SUCCESS;
371 }
372
373 NTSTATUS
374 CUSBQueue::AddUSBRequest(
375 PURB Urb)
376 {
377 UNIMPLEMENTED
378 return STATUS_NOT_IMPLEMENTED;
379 }
380
381 NTSTATUS
382 CUSBQueue::CancelRequests()
383 {
384 UNIMPLEMENTED
385 return STATUS_NOT_IMPLEMENTED;
386 }
387
388 NTSTATUS
389 CUSBQueue::CreateUSBRequest(
390 IUSBRequest **OutRequest)
391 {
392 PUSBREQUEST UsbRequest;
393 NTSTATUS Status;
394
395 *OutRequest = NULL;
396 Status = InternalCreateUSBRequest(&UsbRequest);
397
398 if (NT_SUCCESS(Status))
399 {
400 *OutRequest = UsbRequest;
401 }
402
403 return Status;
404 }
405
406 //
407 // LinkQueueHead - Links one QueueHead to the end of HeadQueueHead list, updating HorizontalLinkPointer.
408 //
409 VOID
410 CUSBQueue::LinkQueueHead(
411 PQUEUE_HEAD HeadQueueHead,
412 PQUEUE_HEAD NewQueueHead)
413 {
414 PQUEUE_HEAD LastQueueHead, NextQueueHead;
415 PLIST_ENTRY Entry;
416 ASSERT(HeadQueueHead);
417 ASSERT(NewQueueHead);
418
419 //
420 // Link the LIST_ENTRYs
421 //
422 InsertTailList(&HeadQueueHead->LinkedQueueHeads, &NewQueueHead->LinkedQueueHeads);
423
424 //
425 // Update HLP for Previous QueueHead, which should be the last in list.
426 //
427 Entry = NewQueueHead->LinkedQueueHeads.Blink;
428 LastQueueHead = CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
429 LastQueueHead->HorizontalLinkPointer = (NewQueueHead->PhysicalAddr | QH_TYPE_QH);
430
431 //
432 // Update HLP for NewQueueHead to point to next, which should be the HeadQueueHead
433 //
434 Entry = NewQueueHead->LinkedQueueHeads.Flink;
435 NextQueueHead = CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
436 ASSERT(NextQueueHead == HeadQueueHead);
437 NewQueueHead->HorizontalLinkPointer = (NextQueueHead->PhysicalAddr | QH_TYPE_QH);
438 }
439
440 //
441 // UnlinkQueueHead - Unlinks one QueueHead, updating HorizontalLinkPointer.
442 //
443 VOID
444 CUSBQueue::UnlinkQueueHead(
445 PQUEUE_HEAD QueueHead)
446 {
447 PQUEUE_HEAD PreviousQH, NextQH;
448 PLIST_ENTRY Entry;
449
450 //
451 // sanity check: there must be at least one queue head with halted bit set
452 //
453 PC_ASSERT(QueueHead->Token.Bits.Halted == 0);
454
455 //
456 // get previous link
457 //
458 Entry = QueueHead->LinkedQueueHeads.Blink;
459
460 //
461 // get queue head structure
462 //
463 PreviousQH = CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
464
465 //
466 // get next link
467 //
468 Entry = QueueHead->LinkedQueueHeads.Flink;
469
470 //
471 // get queue head structure
472 //
473 NextQH = CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
474
475 //
476 // sanity check
477 //
478 ASSERT(QueueHead->HorizontalLinkPointer == (NextQH->PhysicalAddr | QH_TYPE_QH));
479
480 //
481 // remove queue head from linked list
482 //
483 PreviousQH->HorizontalLinkPointer = NextQH->PhysicalAddr | QH_TYPE_QH;
484
485 //
486 // remove software link
487 //
488 RemoveEntryList(&QueueHead->LinkedQueueHeads);
489 }
490
491 //
492 // LinkQueueHeadChain - Links a list of QueueHeads to the HeadQueueHead list, updating HorizontalLinkPointer.
493 //
494 VOID
495 CUSBQueue::LinkQueueHeadChain(
496 PQUEUE_HEAD HeadQueueHead,
497 PQUEUE_HEAD NewQueueHead)
498 {
499 PQUEUE_HEAD LastQueueHead;
500 PLIST_ENTRY Entry;
501 ASSERT(HeadQueueHead);
502 ASSERT(NewQueueHead);
503
504 //
505 // Find the last QueueHead in NewQueueHead
506 //
507 Entry = NewQueueHead->LinkedQueueHeads.Blink;
508 ASSERT(Entry != NewQueueHead->LinkedQueueHeads.Flink);
509 LastQueueHead = CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
510
511 //
512 // Set the LinkPointer and Flink
513 //
514 LastQueueHead->HorizontalLinkPointer = HeadQueueHead->PhysicalAddr | QH_TYPE_QH;
515 LastQueueHead->LinkedQueueHeads.Flink = &HeadQueueHead->LinkedQueueHeads;
516
517 //
518 // Fine the last QueueHead in HeadQueueHead
519 //
520 Entry = HeadQueueHead->LinkedQueueHeads.Blink;
521 HeadQueueHead->LinkedQueueHeads.Blink = &LastQueueHead->LinkedQueueHeads;
522 LastQueueHead = CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
523 LastQueueHead->LinkedQueueHeads.Flink = &NewQueueHead->LinkedQueueHeads;
524 LastQueueHead->HorizontalLinkPointer = NewQueueHead->PhysicalAddr | QH_TYPE_QH;
525 }
526
527 //
528 // UnlinkQueueHeadChain - Unlinks a list number of QueueHeads from HeadQueueHead list, updating HorizontalLinkPointer.
529 // returns the chain of QueueHeads removed from HeadQueueHead.
530 //
531 PQUEUE_HEAD
532 CUSBQueue::UnlinkQueueHeadChain(
533 PQUEUE_HEAD HeadQueueHead,
534 ULONG Count)
535 {
536 PQUEUE_HEAD LastQueueHead, FirstQueueHead;
537 PLIST_ENTRY Entry;
538 ULONG Index;
539
540 //
541 // Find the last QueueHead in NewQueueHead
542 //
543 Entry = &HeadQueueHead->LinkedQueueHeads;
544 FirstQueueHead = CONTAINING_RECORD(Entry->Flink, QUEUE_HEAD, LinkedQueueHeads);
545
546 for (Index = 0; Index < Count; Index++)
547 {
548 Entry = Entry->Flink;
549
550 if (Entry == &HeadQueueHead->LinkedQueueHeads)
551 {
552 DPRINT1("Warnnig; Only %d QueueHeads in HeadQueueHead\n", Index);
553 Count = Index + 1;
554 break;
555 }
556 }
557
558 LastQueueHead = CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
559 HeadQueueHead->LinkedQueueHeads.Flink = LastQueueHead->LinkedQueueHeads.Flink;
560 if (Count + 1 == Index)
561 {
562 HeadQueueHead->LinkedQueueHeads.Blink = &HeadQueueHead->LinkedQueueHeads;
563 }
564 else
565 HeadQueueHead->LinkedQueueHeads.Blink = LastQueueHead->LinkedQueueHeads.Flink;
566
567 FirstQueueHead->LinkedQueueHeads.Blink = &LastQueueHead->LinkedQueueHeads;
568 LastQueueHead->LinkedQueueHeads.Flink = &FirstQueueHead->LinkedQueueHeads;
569 LastQueueHead->HorizontalLinkPointer = TERMINATE_POINTER;
570 return FirstQueueHead;
571 }
572
573 VOID
574 CUSBQueue::QueueHeadCompletion(
575 PQUEUE_HEAD CurrentQH,
576 NTSTATUS Status)
577 {
578 KIRQL OldLevel;
579
580 //
581 // now unlink the queue head
582 // FIXME: implement chained queue heads
583 // no need to acquire locks, as it is called with locks held
584 //
585
586 //
587 // unlink queue head
588 //
589 UnlinkQueueHead(CurrentQH);
590
591 //
592 // insert into completed list
593 //
594 InsertTailList(&m_CompletedRequestAsyncList, &CurrentQH->LinkedQueueHeads);
595 }
596
597 VOID
598 CUSBQueue::ProcessAsyncList(
599 IN NTSTATUS Status,
600 OUT PULONG ShouldRingDoorBell)
601 {
602 KIRQL OldLevel;
603 PLIST_ENTRY Entry;
604 PQUEUE_HEAD QueueHead;
605 IUSBRequest * Request;
606 BOOLEAN IsQueueHeadComplete;
607
608 //
609 // lock completed async list
610 //
611 KeAcquireSpinLock(&m_Lock, &OldLevel);
612
613 //
614 // walk async list
615 //
616 Entry = AsyncListQueueHead->LinkedQueueHeads.Flink;
617
618 while(Entry != &AsyncListQueueHead->LinkedQueueHeads)
619 {
620 //
621 // get queue head structure
622 //
623 QueueHead = (PQUEUE_HEAD)CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
624
625 //
626 // sanity check
627 //
628 PC_ASSERT(QueueHead->Request);
629
630 //
631 // get IUSBRequest interface
632 //
633 Request = (IUSBRequest*)QueueHead->Request;
634
635 //
636 // move to next entry
637 //
638 Entry = Entry->Flink;
639
640 //
641 // check if queue head is complete
642 //
643 IsQueueHeadComplete = Request->IsQueueHeadComplete(QueueHead);
644
645 DPRINT("Request %p QueueHead %p Complete %d\n", Request, QueueHead, IsQueueHeadComplete);
646
647 //
648 // check if queue head is complete
649 //
650 if (IsQueueHeadComplete)
651 {
652 //
653 // current queue head is complete
654 //
655 QueueHeadCompletion(QueueHead, Status);
656
657 //
658 // ring door bell is going to be necessary
659 //
660 *ShouldRingDoorBell = TRUE;
661 }
662 }
663
664 //
665 // release lock
666 //
667 KeReleaseSpinLock(&m_Lock, OldLevel);
668 }
669
670
671 VOID
672 CUSBQueue::InterruptCallback(
673 IN NTSTATUS Status,
674 OUT PULONG ShouldRingDoorBell)
675 {
676
677 DPRINT("CUSBQueue::InterruptCallback\n");
678
679 //
680 // iterate asynchronous list
681 //
682 *ShouldRingDoorBell = FALSE;
683 ProcessAsyncList(Status, ShouldRingDoorBell);
684
685 //
686 // TODO: implement periodic schedule processing
687 //
688 }
689
690 VOID
691 CUSBQueue::QueueHeadCleanup(
692 PQUEUE_HEAD CurrentQH)
693 {
694 PQUEUE_HEAD NewQueueHead;
695 IUSBRequest * Request;
696 BOOLEAN ShouldReleaseWhenDone;
697 USBD_STATUS UrbStatus;
698
699 //
700 // sanity checks
701 //
702 PC_ASSERT(CurrentQH->Token.Bits.Active == 0);
703 PC_ASSERT(CurrentQH->Request);
704
705
706 //
707 // get request
708 //
709 Request = (IUSBRequest*)CurrentQH->Request;
710
711 //
712 // sanity check
713 //
714 PC_ASSERT(Request);
715
716 //
717 // check if the queue head was completed with errors
718 //
719 if (CurrentQH->Token.Bits.Halted)
720 {
721 if (CurrentQH->Token.Bits.DataBufferError)
722 {
723 //
724 // data buffer error
725 //
726 UrbStatus = USBD_STATUS_DATA_BUFFER_ERROR;
727 }
728 else if (CurrentQH->Token.Bits.BabbleDetected)
729 {
730 //
731 // babble detected
732 //
733 UrbStatus = USBD_STATUS_BABBLE_DETECTED;
734 }
735 else
736 {
737 //
738 // stall pid
739 //
740 UrbStatus = USBD_STATUS_STALL_PID;
741 }
742 }
743 else
744 {
745 //
746 // well done ;)
747 //
748 UrbStatus = USBD_STATUS_SUCCESS;
749 }
750
751 //
752 // Check if the transfer was completed and if UrbStatus is ok
753 //
754 if ((Request->IsRequestComplete() == FALSE) && (UrbStatus == USBD_STATUS_SUCCESS))
755 {
756 //
757 // let IUSBRequest free the queue head
758 //
759 Request->FreeQueueHead(CurrentQH);
760
761 //
762 // request is incomplete, get new queue head
763 //
764 if (Request->GetQueueHead(&NewQueueHead) == STATUS_SUCCESS)
765 {
766 //
767 // add to pending list
768 //
769 InsertTailList(&m_PendingRequestAsyncList, &NewQueueHead->LinkedQueueHeads);
770
771 //
772 // Done for now
773 //
774 return;
775 }
776 DPRINT1("Unable to create a new QueueHead\n");
777 PC_ASSERT(FALSE);
778
779 //
780 // Else there was a problem
781 // FIXME: Find better return
782 UrbStatus = USBD_STATUS_INSUFFICIENT_RESOURCES;
783 }
784
785 if (UrbStatus != USBD_STATUS_SUCCESS) PC_ASSERT(FALSE);
786
787 //
788 // notify request that a transfer has completed
789 //
790 Request->CompletionCallback(UrbStatus != USBD_STATUS_SUCCESS ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS,
791 UrbStatus,
792 CurrentQH);
793
794 //
795 // let IUSBRequest free the queue head
796 //
797 Request->FreeQueueHead(CurrentQH);
798
799 //
800 // check if we should release request when done
801 //
802 ShouldReleaseWhenDone = Request->ShouldReleaseRequestAfterCompletion();
803
804 //
805 // release reference when the request was added
806 //
807 Request->Release();
808
809 //
810 // check if the operation was asynchronous
811 //
812 if (ShouldReleaseWhenDone)
813 {
814 //
815 // release outstanding reference count
816 //
817 Request->Release();
818 }
819
820 //
821 // request is now released
822 //
823 }
824
825 VOID
826 CUSBQueue::CompleteAsyncRequests()
827 {
828 KIRQL OldLevel;
829 PLIST_ENTRY Entry;
830 PQUEUE_HEAD CurrentQH;
831 IUSBRequest *Request;
832
833 DPRINT("CUSBQueue::CompleteAsyncRequests\n");
834
835 //
836 // first acquire request lock
837 //
838 KeAcquireSpinLock(&m_Lock, &OldLevel);
839
840 //
841 // the list should not be empty
842 //
843 PC_ASSERT(!IsListEmpty(&m_CompletedRequestAsyncList));
844
845 while(!IsListEmpty(&m_CompletedRequestAsyncList))
846 {
847 //
848 // remove first entry
849 //
850 Entry = RemoveHeadList(&m_CompletedRequestAsyncList);
851
852 //
853 // get queue head structure
854 //
855 CurrentQH = (PQUEUE_HEAD)CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
856
857 //
858 // Get the Request for this QueueHead
859 //
860 Request = (IUSBRequest*) CurrentQH->Request;
861
862 //
863 // complete request now
864 //
865 QueueHeadCleanup(CurrentQH);
866 }
867
868 //
869 // is there a pending async entry
870 //
871 if (!IsListEmpty(&m_PendingRequestAsyncList))
872 {
873 //
874 // remove first entry
875 //
876 Entry = RemoveHeadList(&m_PendingRequestAsyncList);
877
878 //
879 // get queue head structure
880 //
881 CurrentQH = (PQUEUE_HEAD)CONTAINING_RECORD(Entry, QUEUE_HEAD, LinkedQueueHeads);
882
883 //
884 // Add it to the AsyncList list
885 //
886 LinkQueueHead(AsyncListQueueHead, CurrentQH);
887 }
888
889 //
890 // release lock
891 //
892 KeReleaseSpinLock(&m_Lock, OldLevel);
893 }
894
895 NTSTATUS
896 CreateUSBQueue(
897 PUSBQUEUE *OutUsbQueue)
898 {
899 PUSBQUEUE This;
900
901 //
902 // allocate controller
903 //
904 This = new(NonPagedPool, TAG_USBEHCI) CUSBQueue(0);
905 if (!This)
906 {
907 //
908 // failed to allocate
909 //
910 return STATUS_INSUFFICIENT_RESOURCES;
911 }
912
913 //
914 // add reference count
915 //
916 This->AddRef();
917
918 //
919 // return result
920 //
921 *OutUsbQueue = (PUSBQUEUE)This;
922
923 //
924 // done
925 //
926 return STATUS_SUCCESS;
927 }