5d0fa1491d4225547f63d00bbd13a459ea823203
[reactos.git] / drivers / usb / usbohci / 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/usbohci/usb_queue.cpp
5 * PURPOSE: USB OHCI device driver.
6 * PROGRAMMERS:
7 * Michael Martin (michael.martin@reactos.org)
8 * Johannes Anderwald (johannes.anderwald@reactos.org)
9 */
10
11 #include "usbohci.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 // com
37 virtual NTSTATUS Initialize(IN PUSBHARDWAREDEVICE Hardware, PDMA_ADAPTER AdapterObject, IN PDMAMEMORYMANAGER MemManager, IN OPTIONAL PKSPIN_LOCK Lock);
38 virtual ULONG GetPendingRequestCount();
39 virtual NTSTATUS AddUSBRequest(IUSBRequest * Request);
40 virtual NTSTATUS CancelRequests();
41 virtual NTSTATUS CreateUSBRequest(IUSBRequest **OutRequest);
42 virtual VOID TransferDescriptorCompletionCallback(ULONG TransferDescriptorLogicalAddress);
43
44 // local functions
45 BOOLEAN IsTransferDescriptorInEndpoint(IN POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor, IN ULONG TransferDescriptorLogicalAddress);
46 BOOLEAN IsTransferDescriptorInIsoEndpoint(IN POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor, IN ULONG TransferDescriptorLogicalAddress);
47 NTSTATUS FindTransferDescriptorInEndpoint(IN POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor, IN ULONG TransferDescriptorLogicalAddress, OUT POHCI_ENDPOINT_DESCRIPTOR *OutEndpointDescriptor, OUT POHCI_ENDPOINT_DESCRIPTOR *OutPreviousEndpointDescriptor);
48 NTSTATUS FindTransferDescriptorInInterruptHeadEndpoints(IN ULONG TransferDescriptorLogicalAddress, OUT POHCI_ENDPOINT_DESCRIPTOR *OutEndpointDescriptor, OUT POHCI_ENDPOINT_DESCRIPTOR *OutPreviousEndpointDescriptor);
49 NTSTATUS FindTransferDescriptorInIsochronousHeadEndpoints(IN ULONG TransferDescriptorLogicalAddress, OUT POHCI_ENDPOINT_DESCRIPTOR *OutEndpointDescriptor, OUT POHCI_ENDPOINT_DESCRIPTOR *OutPreviousEndpointDescriptor);
50
51 VOID CleanupEndpointDescriptor(POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor, POHCI_ENDPOINT_DESCRIPTOR PreviousEndpointDescriptor);
52 POHCI_ENDPOINT_DESCRIPTOR FindInterruptEndpointDescriptor(UCHAR InterruptInterval);
53 VOID PrintEndpointList(POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor);
54 VOID LinkEndpoint(POHCI_ENDPOINT_DESCRIPTOR HeadEndpointDescriptor, POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor);
55
56 // constructor / destructor
57 CUSBQueue(IUnknown *OuterUnknown){}
58 virtual ~CUSBQueue(){}
59
60 protected:
61 LONG m_Ref; // reference count
62 KSPIN_LOCK m_Lock; // list lock
63 PUSBHARDWAREDEVICE m_Hardware; // hardware
64 POHCI_ENDPOINT_DESCRIPTOR m_BulkHeadEndpointDescriptor; // bulk head descriptor
65 POHCI_ENDPOINT_DESCRIPTOR m_ControlHeadEndpointDescriptor; // control head descriptor
66 POHCI_ENDPOINT_DESCRIPTOR m_IsoHeadEndpointDescriptor; // isochronous head descriptor
67 POHCI_ENDPOINT_DESCRIPTOR * m_InterruptEndpoints;
68 };
69
70 //=================================================================================================
71 // COM
72 //
73 NTSTATUS
74 STDMETHODCALLTYPE
75 CUSBQueue::QueryInterface(
76 IN REFIID refiid,
77 OUT PVOID* Output)
78 {
79 if (IsEqualGUIDAligned(refiid, IID_IUnknown))
80 {
81 *Output = PVOID(PUNKNOWN(this));
82 PUNKNOWN(*Output)->AddRef();
83 return STATUS_SUCCESS;
84 }
85
86 return STATUS_UNSUCCESSFUL;
87 }
88
89 NTSTATUS
90 CUSBQueue::Initialize(
91 IN PUSBHARDWAREDEVICE Hardware,
92 IN PDMA_ADAPTER AdapterObject,
93 IN PDMAMEMORYMANAGER MemManager,
94 IN OPTIONAL PKSPIN_LOCK Lock)
95 {
96 //
97 // get bulk endpoint descriptor
98 //
99 Hardware->GetBulkHeadEndpointDescriptor(&m_BulkHeadEndpointDescriptor);
100
101 //
102 // get control endpoint descriptor
103 //
104 Hardware->GetControlHeadEndpointDescriptor(&m_ControlHeadEndpointDescriptor);
105
106 //
107 // get isochronous endpoint
108 //
109 Hardware->GetIsochronousHeadEndpointDescriptor(&m_IsoHeadEndpointDescriptor);
110
111 //
112 // get interrupt endpoints
113 //
114 Hardware->GetInterruptEndpointDescriptors(&m_InterruptEndpoints);
115
116 //
117 // initialize spinlock
118 //
119 KeInitializeSpinLock(&m_Lock);
120
121 //
122 // store hardware
123 //
124 m_Hardware = Hardware;
125
126 return STATUS_SUCCESS;
127 }
128
129 ULONG
130 CUSBQueue::GetPendingRequestCount()
131 {
132 //
133 // Loop through the pending list and iterrate one for each QueueHead that
134 // has a IRP to complete.
135 //
136
137 return 0;
138 }
139
140 VOID
141 CUSBQueue::LinkEndpoint(
142 POHCI_ENDPOINT_DESCRIPTOR HeadEndpointDescriptor,
143 POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor)
144 {
145 POHCI_ENDPOINT_DESCRIPTOR CurrentEndpointDescriptor = HeadEndpointDescriptor;
146
147 //
148 // get last descriptor in queue
149 //
150 while(CurrentEndpointDescriptor->NextDescriptor)
151 {
152 //
153 // move to last descriptor
154 //
155 CurrentEndpointDescriptor = (POHCI_ENDPOINT_DESCRIPTOR)CurrentEndpointDescriptor->NextDescriptor;
156 }
157
158 //
159 // link endpoints
160 //
161 CurrentEndpointDescriptor->NextPhysicalEndpoint = EndpointDescriptor->PhysicalAddress.LowPart;
162 CurrentEndpointDescriptor->NextDescriptor = EndpointDescriptor;
163
164 }
165
166 NTSTATUS
167 CUSBQueue::AddUSBRequest(
168 IUSBRequest * Request)
169 {
170 NTSTATUS Status;
171 ULONG Type;
172 POHCI_ENDPOINT_DESCRIPTOR HeadDescriptor;
173 POHCI_ENDPOINT_DESCRIPTOR Descriptor;
174 POHCI_ISO_TD CurrentDescriptor;
175 ULONG FrameNumber;
176 USHORT Frame;
177
178 DPRINT("CUSBQueue::AddUSBRequest\n");
179
180 //
181 // sanity check
182 //
183 ASSERT(Request != NULL);
184
185 //
186 // get request type
187 //
188 Type = Request->GetTransferType();
189
190 //
191 // add extra reference which is released when the request is completed
192 //
193 Request->AddRef();
194
195 //
196 // get transfer descriptors
197 //
198 Status = Request->GetEndpointDescriptor(&Descriptor);
199 if (!NT_SUCCESS(Status))
200 {
201 //
202 // failed to get transfer descriptor
203 //
204 DPRINT1("CUSBQueue::AddUSBRequest GetEndpointDescriptor failed with %x\n", Status);
205
206 //
207 // release reference
208 //
209 Request->Release();
210 return Status;
211 }
212
213 //
214 // check type
215 //
216 if (Type == USB_ENDPOINT_TYPE_BULK)
217 {
218 //
219 // get head descriptor
220 //
221 HeadDescriptor = m_BulkHeadEndpointDescriptor;
222 }
223 else if (Type == USB_ENDPOINT_TYPE_CONTROL)
224 {
225 //
226 // get head descriptor
227 //
228 HeadDescriptor = m_ControlHeadEndpointDescriptor;
229 }
230 else if (Type == USB_ENDPOINT_TYPE_INTERRUPT)
231 {
232 //
233 // get head descriptor
234 //
235 HeadDescriptor = FindInterruptEndpointDescriptor(Request->GetInterval());
236 ASSERT(HeadDescriptor);
237 }
238 else if (Type == USB_ENDPOINT_TYPE_ISOCHRONOUS)
239 {
240 //
241 // get head descriptor
242 //
243 HeadDescriptor = m_IsoHeadEndpointDescriptor;
244
245 //
246 // get current frame number
247 //
248 m_Hardware->GetCurrentFrameNumber(&FrameNumber);
249
250 //
251 // FIXME: increment frame number
252 //
253 FrameNumber += 300;
254
255 //
256 // apply frame number to iso transfer descriptors
257 //
258 CurrentDescriptor = (POHCI_ISO_TD)Descriptor->HeadLogicalDescriptor;
259
260 DPRINT1("ISO: NextFrameNumber %x\n", FrameNumber);
261 Frame = (FrameNumber & 0xFFFF);
262
263 while(CurrentDescriptor)
264 {
265 //
266 // set current frame number
267 //
268 CurrentDescriptor->Flags |= OHCI_ITD_SET_STARTING_FRAME(Frame);
269
270 //
271 // move to next frame number
272 //
273 Frame += OHCI_ITD_GET_FRAME_COUNT(CurrentDescriptor->Flags);
274
275 //
276 // move to next descriptor
277 //
278 CurrentDescriptor = CurrentDescriptor->NextLogicalDescriptor;
279 }
280
281 //
282 // get current frame number
283 //
284 m_Hardware->GetCurrentFrameNumber(&FrameNumber);
285
286 DPRINT1("Hardware 1ms %p Iso %p\n",m_InterruptEndpoints[0], m_IsoHeadEndpointDescriptor);
287 ASSERT(m_InterruptEndpoints[0]->NextPhysicalEndpoint == m_IsoHeadEndpointDescriptor->PhysicalAddress.LowPart);
288
289 PrintEndpointList(m_IsoHeadEndpointDescriptor);
290 }
291 else
292 {
293 //
294 // bad request type
295 //
296 Request->Release();
297 return STATUS_INVALID_PARAMETER;
298 }
299
300 //
301 // set descriptor active
302 //
303 Descriptor->Flags &= ~OHCI_ENDPOINT_SKIP;
304
305 //
306 // insert endpoint at end
307 //
308 LinkEndpoint(HeadDescriptor, Descriptor);
309
310 if (Type == USB_ENDPOINT_TYPE_CONTROL || Type == USB_ENDPOINT_TYPE_BULK)
311 {
312 //
313 // notify hardware of our request
314 //
315 m_Hardware->HeadEndpointDescriptorModified(Type);
316 }
317
318 return STATUS_SUCCESS;
319 }
320
321 NTSTATUS
322 CUSBQueue::CancelRequests()
323 {
324 UNIMPLEMENTED
325 return STATUS_NOT_IMPLEMENTED;
326 }
327
328 NTSTATUS
329 CUSBQueue::CreateUSBRequest(
330 IUSBRequest **OutRequest)
331 {
332 PUSBREQUEST UsbRequest;
333 NTSTATUS Status;
334
335 *OutRequest = NULL;
336 Status = InternalCreateUSBRequest(&UsbRequest);
337
338 if (NT_SUCCESS(Status))
339 {
340 *OutRequest = UsbRequest;
341 }
342
343 return Status;
344 }
345
346 NTSTATUS
347 CUSBQueue::FindTransferDescriptorInEndpoint(
348 IN POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor,
349 IN ULONG TransferDescriptorLogicalAddress,
350 OUT POHCI_ENDPOINT_DESCRIPTOR *OutEndpointDescriptor,
351 OUT POHCI_ENDPOINT_DESCRIPTOR *OutPreviousEndpointDescriptor)
352 {
353 POHCI_ENDPOINT_DESCRIPTOR LastDescriptor = EndpointDescriptor;
354
355
356 //
357 // skip first endpoint head
358 //
359 EndpointDescriptor = (POHCI_ENDPOINT_DESCRIPTOR)EndpointDescriptor->NextDescriptor;
360
361 while(EndpointDescriptor)
362 {
363 //
364 // check if the transfer descriptor is inside the list
365 //
366 if (IsTransferDescriptorInEndpoint(EndpointDescriptor, TransferDescriptorLogicalAddress))
367 {
368 //
369 // found endpoint
370 //
371 *OutEndpointDescriptor = EndpointDescriptor;
372 *OutPreviousEndpointDescriptor = LastDescriptor;
373
374 //
375 // done
376 //
377 return STATUS_SUCCESS;
378 }
379
380 //
381 // store last endpoint
382 //
383 LastDescriptor = EndpointDescriptor;
384
385 //
386 // move to next
387 //
388 EndpointDescriptor = (POHCI_ENDPOINT_DESCRIPTOR)EndpointDescriptor->NextDescriptor;
389 }
390
391 //
392 // failed to endpoint
393 //
394 return STATUS_NOT_FOUND;
395 }
396
397 NTSTATUS
398 CUSBQueue::FindTransferDescriptorInInterruptHeadEndpoints(IN ULONG TransferDescriptorLogicalAddress, OUT POHCI_ENDPOINT_DESCRIPTOR *OutEndpointDescriptor, OUT POHCI_ENDPOINT_DESCRIPTOR *OutPreviousEndpointDescriptor)
399 {
400 ULONG Index;
401 NTSTATUS Status;
402
403 //
404 // search descriptor in endpoint list
405 //
406 for(Index = 0; Index < OHCI_STATIC_ENDPOINT_COUNT; Index++)
407 {
408 //
409 // is it in current endpoint
410 //
411 Status = FindTransferDescriptorInEndpoint(m_InterruptEndpoints[Index], TransferDescriptorLogicalAddress, OutEndpointDescriptor, OutPreviousEndpointDescriptor);
412 if (NT_SUCCESS(Status))
413 {
414 //
415 // found transfer descriptor
416 //
417 return STATUS_SUCCESS;
418 }
419 }
420
421 //
422 // not found
423 //
424 return STATUS_NOT_FOUND;
425 }
426
427 NTSTATUS
428 CUSBQueue::FindTransferDescriptorInIsochronousHeadEndpoints(
429 IN ULONG TransferDescriptorLogicalAddress,
430 OUT POHCI_ENDPOINT_DESCRIPTOR *OutEndpointDescriptor,
431 OUT POHCI_ENDPOINT_DESCRIPTOR *OutPreviousEndpointDescriptor)
432 {
433 POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor;
434 POHCI_ENDPOINT_DESCRIPTOR LastDescriptor = m_IsoHeadEndpointDescriptor;
435
436
437 //
438 // skip first endpoint head
439 //
440 EndpointDescriptor = (POHCI_ENDPOINT_DESCRIPTOR)m_IsoHeadEndpointDescriptor->NextDescriptor;
441
442 while(EndpointDescriptor)
443 {
444 //
445 // check if the transfer descriptor is inside the list
446 //
447 if (IsTransferDescriptorInIsoEndpoint(EndpointDescriptor, TransferDescriptorLogicalAddress))
448 {
449 //
450 // found endpoint
451 //
452 *OutEndpointDescriptor = EndpointDescriptor;
453 *OutPreviousEndpointDescriptor = LastDescriptor;
454
455 //
456 // done
457 //
458 return STATUS_SUCCESS;
459 }
460
461 //
462 // store last endpoint
463 //
464 LastDescriptor = EndpointDescriptor;
465
466 //
467 // move to next
468 //
469 EndpointDescriptor = (POHCI_ENDPOINT_DESCRIPTOR)EndpointDescriptor->NextDescriptor;
470 }
471
472 //
473 // failed to endpoint
474 //
475 return STATUS_NOT_FOUND;
476 }
477
478 BOOLEAN
479 CUSBQueue::IsTransferDescriptorInIsoEndpoint(
480 IN POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor,
481 IN ULONG TransferDescriptorLogicalAddress)
482 {
483 POHCI_ISO_TD Descriptor;
484
485 //
486 // get first general transfer descriptor
487 //
488 Descriptor = (POHCI_ISO_TD)EndpointDescriptor->HeadLogicalDescriptor;
489
490 //
491 // sanity check
492 //
493 ASSERT(Descriptor);
494
495 do
496 {
497 if (Descriptor->PhysicalAddress.LowPart == TransferDescriptorLogicalAddress)
498 {
499 //
500 // found descriptor
501 //
502 return TRUE;
503 }
504
505 //
506 // move to next
507 //
508 Descriptor = (POHCI_ISO_TD)Descriptor->NextLogicalDescriptor;
509 }while(Descriptor);
510
511 //
512 // no descriptor found
513 //
514 return FALSE;
515 }
516
517
518 BOOLEAN
519 CUSBQueue::IsTransferDescriptorInEndpoint(
520 IN POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor,
521 IN ULONG TransferDescriptorLogicalAddress)
522 {
523 POHCI_GENERAL_TD Descriptor;
524
525 //
526 // get first general transfer descriptor
527 //
528 Descriptor = (POHCI_GENERAL_TD)EndpointDescriptor->HeadLogicalDescriptor;
529
530 //
531 // sanity check
532 //
533 ASSERT(Descriptor);
534
535 do
536 {
537 if (Descriptor->PhysicalAddress.LowPart == TransferDescriptorLogicalAddress)
538 {
539 //
540 // found descriptor
541 //
542 return TRUE;
543 }
544
545 //
546 // move to next
547 //
548 Descriptor = (POHCI_GENERAL_TD)Descriptor->NextLogicalDescriptor;
549 }while(Descriptor);
550
551
552 //
553 // no descriptor found
554 //
555 return FALSE;
556 }
557
558 VOID
559 CUSBQueue::CleanupEndpointDescriptor(
560 POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor,
561 POHCI_ENDPOINT_DESCRIPTOR PreviousEndpointDescriptor)
562 {
563 PUSBREQUEST Request;
564
565 //
566 // FIXME: verify unlinking process
567 //
568 PreviousEndpointDescriptor->NextDescriptor = EndpointDescriptor->NextDescriptor;
569 PreviousEndpointDescriptor->NextPhysicalEndpoint = EndpointDescriptor->NextPhysicalEndpoint;
570
571 //
572 // get corresponding request
573 //
574 Request = PUSBREQUEST(EndpointDescriptor->Request);
575 ASSERT(Request);
576
577 //
578 // notify of completion
579 //
580 Request->CompletionCallback(EndpointDescriptor);
581
582 //
583 // free endpoint descriptor
584 //
585 Request->FreeEndpointDescriptor(EndpointDescriptor);
586
587 //
588 // FIXME: check if complete
589 //
590 //ASSERT(Request->IsRequestComplete());
591
592 Request->FreeEndpointDescriptor(EndpointDescriptor);
593
594 //
595 // release request
596 //
597 Request->Release();
598
599 }
600 VOID
601 CUSBQueue::PrintEndpointList(
602 POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor)
603 {
604 DPRINT1("CUSBQueue::PrintEndpointList HeadEndpoint %p Logical %x\n", EndpointDescriptor, EndpointDescriptor->PhysicalAddress.LowPart);
605
606 //
607 // get first general transfer descriptor
608 //
609 EndpointDescriptor = (POHCI_ENDPOINT_DESCRIPTOR)EndpointDescriptor->NextDescriptor;
610
611 while(EndpointDescriptor)
612 {
613 DPRINT1(" CUSBQueue::PrintEndpointList Endpoint %p Logical %x\n", EndpointDescriptor, EndpointDescriptor->PhysicalAddress.LowPart);
614
615 //
616 // move to next
617 //
618 EndpointDescriptor = (POHCI_ENDPOINT_DESCRIPTOR)EndpointDescriptor->NextDescriptor;
619 }
620 }
621
622 VOID
623 CUSBQueue::TransferDescriptorCompletionCallback(
624 ULONG TransferDescriptorLogicalAddress)
625 {
626 POHCI_ENDPOINT_DESCRIPTOR EndpointDescriptor, PreviousEndpointDescriptor;
627 NTSTATUS Status;
628
629 DPRINT("CUSBQueue::TransferDescriptorCompletionCallback transfer descriptor %x\n", TransferDescriptorLogicalAddress);
630
631 //
632 // find transfer descriptor in control list
633 //
634 Status = FindTransferDescriptorInEndpoint(m_ControlHeadEndpointDescriptor, TransferDescriptorLogicalAddress, &EndpointDescriptor, &PreviousEndpointDescriptor);
635 if (NT_SUCCESS(Status))
636 {
637 //
638 // cleanup endpoint
639 //
640 CleanupEndpointDescriptor(EndpointDescriptor, PreviousEndpointDescriptor);
641
642 //
643 // done
644 //
645 return;
646 }
647
648 //
649 // find transfer descriptor in bulk list
650 //
651 Status = FindTransferDescriptorInEndpoint(m_BulkHeadEndpointDescriptor, TransferDescriptorLogicalAddress, &EndpointDescriptor, &PreviousEndpointDescriptor);
652 if (NT_SUCCESS(Status))
653 {
654 //
655 // cleanup endpoint
656 //
657 CleanupEndpointDescriptor(EndpointDescriptor, PreviousEndpointDescriptor);
658
659 //
660 // done
661 //
662 return;
663 }
664
665 //
666 // find transfer descriptor in interrupt list
667 //
668 Status = FindTransferDescriptorInInterruptHeadEndpoints(TransferDescriptorLogicalAddress, &EndpointDescriptor, &PreviousEndpointDescriptor);
669 if (NT_SUCCESS(Status))
670 {
671 //
672 // cleanup endpoint
673 //
674 CleanupEndpointDescriptor(EndpointDescriptor, PreviousEndpointDescriptor);
675
676 //
677 // done
678 //
679 return;
680 }
681
682 //
683 // last try: find the descriptor in isochronous list
684 //
685 Status = FindTransferDescriptorInIsochronousHeadEndpoints(TransferDescriptorLogicalAddress, &EndpointDescriptor, &PreviousEndpointDescriptor);
686 if (NT_SUCCESS(Status))
687 {
688 //
689 // cleanup endpoint
690 //
691 DPRINT1("ISO endpoint complete\n");
692 ASSERT(FALSE);
693 CleanupEndpointDescriptor(EndpointDescriptor, PreviousEndpointDescriptor);
694
695 //
696 // done
697 //
698 return;
699 }
700
701 //
702 // hardware reported dead endpoint completed
703 //
704 DPRINT1("CUSBQueue::TransferDescriptorCompletionCallback invalid transfer descriptor %x\n", TransferDescriptorLogicalAddress);
705 ASSERT(FALSE);
706 }
707
708 POHCI_ENDPOINT_DESCRIPTOR
709 CUSBQueue::FindInterruptEndpointDescriptor(
710 UCHAR InterruptInterval)
711 {
712 ULONG Index = 0;
713 ULONG Power = 1;
714
715 //
716 // sanity check
717 //
718 ASSERT(InterruptInterval <= OHCI_BIGGEST_INTERVAL);
719
720 //
721 // find interrupt index
722 //
723 while (Power <= OHCI_BIGGEST_INTERVAL / 2)
724 {
725 //
726 // is current interval greater
727 //
728 if (Power * 2 > InterruptInterval)
729 break;
730
731 //
732 // increment power
733 //
734 Power *= 2;
735
736 //
737 // move to next interrupt
738 //
739 Index++;
740 }
741
742 DPRINT("InterruptInterval %lu Selected InterruptIndex %lu Choosen Interval %lu\n", InterruptInterval, Index, Power);
743
744 //
745 // return endpoint
746 //
747 return m_InterruptEndpoints[Index];
748 }
749
750 NTSTATUS
751 CreateUSBQueue(
752 PUSBQUEUE *OutUsbQueue)
753 {
754 PUSBQUEUE This;
755
756 //
757 // allocate controller
758 //
759 This = new(NonPagedPool, TAG_USBOHCI) CUSBQueue(0);
760 if (!This)
761 {
762 //
763 // failed to allocate
764 //
765 return STATUS_INSUFFICIENT_RESOURCES;
766 }
767
768 //
769 // add reference count
770 //
771 This->AddRef();
772
773 //
774 // return result
775 //
776 *OutUsbQueue = (PUSBQUEUE)This;
777
778 //
779 // done
780 //
781 return STATUS_SUCCESS;
782 }