[USBOHCI]
[reactos.git] / drivers / usb / usbohci / usb_device.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_device.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 #define INITGUID
12 #include "usbohci.h"
13
14 class CUSBDevice : public IUSBDevice
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 // IUSBDevice interface functions
37 virtual NTSTATUS Initialize(IN PHUBCONTROLLER HubController, IN PUSBHARDWAREDEVICE Device, IN PVOID Parent, IN ULONG Port, IN ULONG PortStatus);
38 virtual BOOLEAN IsHub();
39 virtual NTSTATUS GetParent(PVOID * Parent);
40 virtual UCHAR GetDeviceAddress();
41 virtual ULONG GetPort();
42 virtual USB_DEVICE_SPEED GetSpeed();
43 virtual USB_DEVICE_TYPE GetType();
44 virtual ULONG GetState();
45 virtual void SetDeviceHandleData(PVOID Data);
46 virtual NTSTATUS SetDeviceAddress(UCHAR DeviceAddress);
47 virtual void GetDeviceDescriptor(PUSB_DEVICE_DESCRIPTOR DeviceDescriptor);
48 virtual UCHAR GetConfigurationValue();
49 virtual NTSTATUS SubmitIrp(PIRP Irp);
50 virtual VOID GetConfigurationDescriptors(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptorBuffer, IN ULONG BufferLength, OUT PULONG OutBufferLength);
51 virtual ULONG GetConfigurationDescriptorsLength();
52 virtual NTSTATUS SubmitSetupPacket(IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket, OUT ULONG BufferLength, OUT PVOID Buffer);
53 virtual NTSTATUS SelectConfiguration(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, IN PUSBD_INTERFACE_INFORMATION Interface, OUT USBD_CONFIGURATION_HANDLE *ConfigurationHandle);
54 virtual NTSTATUS SelectInterface(IN USBD_CONFIGURATION_HANDLE ConfigurationHandle, IN OUT PUSBD_INTERFACE_INFORMATION Interface);
55 virtual NTSTATUS AbortPipe(IN PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor);
56
57 // local function
58 virtual NTSTATUS CommitIrp(PIRP Irp);
59 virtual NTSTATUS CommitSetupPacket(PUSB_DEFAULT_PIPE_SETUP_PACKET Packet, IN OPTIONAL PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor, IN ULONG BufferLength, IN OUT PMDL Mdl);
60 virtual NTSTATUS CreateConfigurationDescriptor(ULONG ConfigurationIndex);
61 virtual NTSTATUS CreateDeviceDescriptor();
62 virtual VOID DumpDeviceDescriptor(PUSB_DEVICE_DESCRIPTOR DeviceDescriptor);
63 virtual VOID DumpConfigurationDescriptor(PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor);
64
65 // constructor / destructor
66 CUSBDevice(IUnknown *OuterUnknown){}
67 virtual ~CUSBDevice(){}
68
69 protected:
70 LONG m_Ref;
71 PHUBCONTROLLER m_HubController;
72 PUSBHARDWAREDEVICE m_Device;
73 PVOID m_Parent;
74 ULONG m_Port;
75 UCHAR m_DeviceAddress;
76 PVOID m_Data;
77 UCHAR m_ConfigurationIndex;
78 KSPIN_LOCK m_Lock;
79 USB_DEVICE_DESCRIPTOR m_DeviceDescriptor;
80 ULONG m_PortStatus;
81 PUSBQUEUE m_Queue;
82 PDMAMEMORYMANAGER m_DmaManager;
83 PUSB_CONFIGURATION_DESCRIPTOR *m_ConfigurationDescriptors;
84 LIST_ENTRY m_IrpListHead;
85
86 };
87
88 //----------------------------------------------------------------------------------------
89 NTSTATUS
90 STDMETHODCALLTYPE
91 CUSBDevice::QueryInterface(
92 IN REFIID refiid,
93 OUT PVOID* Output)
94 {
95 return STATUS_UNSUCCESSFUL;
96 }
97
98 //----------------------------------------------------------------------------------------
99 NTSTATUS
100 CUSBDevice::Initialize(
101 IN PHUBCONTROLLER HubController,
102 IN PUSBHARDWAREDEVICE Device,
103 IN PVOID Parent,
104 IN ULONG Port,
105 IN ULONG PortStatus)
106 {
107 NTSTATUS Status;
108
109 //
110 // initialize members
111 //
112 m_HubController = HubController;
113 m_Device = Device;
114 m_Parent = Parent;
115 m_Port = Port;
116 m_PortStatus = PortStatus;
117
118 //
119 // initialize device lock
120 //
121 KeInitializeSpinLock(&m_Lock);
122
123 //
124 // initialize irp list
125 //
126 InitializeListHead(&m_IrpListHead);
127
128 //
129 // no device address has been set yet
130 //
131 m_DeviceAddress = 0;
132
133 //
134 // get usb request queue
135 //
136 Status = m_Device->GetUSBQueue(&m_Queue);
137 if (!NT_SUCCESS(Status))
138 {
139 //
140 // failed to get usb queue
141 //
142 DPRINT1("CUSBDevice::Initialize GetUsbQueue failed with %x\n", Status);
143 return Status;
144 }
145
146 //
147 // get dma manager
148 //
149 Status = m_Device->GetDMA(&m_DmaManager);
150 if (!NT_SUCCESS(Status))
151 {
152 //
153 // failed to get dma manager
154 //
155 DPRINT1("CUSBDevice::Initialize GetDMA failed with %x\n", Status);
156 return Status;
157 }
158
159 //
160 // sanity check
161 //
162 PC_ASSERT(m_DmaManager);
163
164 //
165 // get device descriptor
166 //
167 Status = CreateDeviceDescriptor();
168 if (!NT_SUCCESS(Status))
169 {
170 //
171 // failed to get device descriptor
172 //
173 DPRINT1("CUSBDevice::Initialize Failed to get device descriptor with %x\n", Status);
174 return Status;
175 }
176
177 //
178 // done
179 //
180 return Status;
181 }
182
183 //----------------------------------------------------------------------------------------
184 BOOLEAN
185 CUSBDevice::IsHub()
186 {
187 //
188 // USB Standard Device Class see http://www.usb.org/developers/defined_class/#BaseClass09h
189 // for details
190 //
191 return (m_DeviceDescriptor.bDeviceClass == 0x09 && m_DeviceDescriptor.bDeviceSubClass == 0x00);
192 }
193
194 //----------------------------------------------------------------------------------------
195 NTSTATUS
196 CUSBDevice::GetParent(
197 PVOID * Parent)
198 {
199 //
200 // returns parent
201 //
202 *Parent = m_Parent;
203
204 //
205 // done
206 //
207 return STATUS_SUCCESS;
208 }
209
210 //----------------------------------------------------------------------------------------
211 UCHAR
212 CUSBDevice::GetDeviceAddress()
213 {
214 //
215 // get device address
216 //
217 return m_DeviceAddress;
218 }
219
220 //----------------------------------------------------------------------------------------
221 ULONG
222 CUSBDevice::GetPort()
223 {
224 //
225 // get port to which this device is connected to
226 //
227 return m_Port;
228 }
229
230 //----------------------------------------------------------------------------------------
231 USB_DEVICE_SPEED
232 CUSBDevice::GetSpeed()
233 {
234 if (m_PortStatus & USB_PORT_STATUS_LOW_SPEED)
235 {
236 //
237 // low speed device
238 //
239 return UsbLowSpeed;
240 }
241 else if (m_PortStatus & USB_PORT_STATUS_HIGH_SPEED)
242 {
243 //
244 // high speed device
245 //
246 return UsbHighSpeed;
247 }
248
249 //
250 // default to full speed
251 //
252 return UsbFullSpeed;
253 }
254
255 //----------------------------------------------------------------------------------------
256 USB_DEVICE_TYPE
257 CUSBDevice::GetType()
258 {
259 //
260 // device is encoded into bcdUSB
261 //
262 if (m_DeviceDescriptor.bcdUSB == 0x110)
263 {
264 //
265 // USB 1.1 device
266 //
267 return Usb11Device;
268 }
269 else if (m_DeviceDescriptor.bcdUSB == 0x200)
270 {
271 //
272 // USB 2.0 device
273 //
274 return Usb20Device;
275 }
276
277 DPRINT1("CUSBDevice::GetType Unknown bcdUSB Type %x\n", m_DeviceDescriptor.bcdUSB);
278 PC_ASSERT(FALSE);
279 return Usb11Device;
280 }
281
282 //----------------------------------------------------------------------------------------
283 ULONG
284 CUSBDevice::GetState()
285 {
286 UNIMPLEMENTED
287 return FALSE;
288 }
289
290 //----------------------------------------------------------------------------------------
291 void
292 CUSBDevice::SetDeviceHandleData(
293 PVOID Data)
294 {
295 //
296 // set device data, for debugging issues
297 //
298 m_Data = Data;
299 }
300
301 //----------------------------------------------------------------------------------------
302 NTSTATUS
303 CUSBDevice::SetDeviceAddress(
304 UCHAR DeviceAddress)
305 {
306 PUSB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
307 NTSTATUS Status;
308 UCHAR OldAddress;
309 ULONG Index;
310
311 DPRINT1("CUSBDevice::SetDeviceAddress Address %d\n", DeviceAddress);
312
313 CtrlSetup = (PUSB_DEFAULT_PIPE_SETUP_PACKET)ExAllocatePoolWithTag(NonPagedPool, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET), TAG_USBOHCI);
314 if (!CtrlSetup)
315 return STATUS_INSUFFICIENT_RESOURCES;
316
317 //
318 // zero request
319 //
320 RtlZeroMemory(CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
321
322 //
323 // initialize request
324 //
325 CtrlSetup->bRequest = USB_REQUEST_SET_ADDRESS;
326 CtrlSetup->wValue.W = (USHORT)DeviceAddress;
327
328 //
329 // set device address
330 //
331 Status = CommitSetupPacket(CtrlSetup, 0, 0, 0);
332
333 //
334 // free setup packet
335 //
336 ExFreePoolWithTag(CtrlSetup, TAG_USBOHCI);
337
338 //
339 // check for success
340 //
341 if (!NT_SUCCESS(Status))
342 {
343 //
344 // failed to set device address
345 //
346 DPRINT1("CUSBDevice::SetDeviceAddress> failed to set device address with %x Address %x\n", Status, DeviceAddress);
347 return Status;
348 }
349
350 //
351 // lets have a short nap
352 //
353 KeStallExecutionProcessor(300);
354
355 //
356 // back up old address
357 //
358 OldAddress = m_DeviceAddress;
359
360 //
361 // store new device address
362 //
363 m_DeviceAddress = DeviceAddress;
364
365 //
366 // check that setting device address succeeded by retrieving the device descriptor
367 //
368 Status = CreateDeviceDescriptor();
369 if (!NT_SUCCESS(Status))
370 {
371 //
372 // failed to retrieve device descriptor
373 //
374 DPRINT1("CUSBbDevice::SetDeviceAddress> failed to retrieve device descriptor with device address set Error %x\n", Status);
375 m_DeviceAddress = OldAddress;
376
377 //
378 // return error status
379 //
380 return Status;
381 }
382
383 //
384 // sanity checks
385 //
386 PC_ASSERT(m_DeviceDescriptor.bNumConfigurations);
387
388 //
389 // allocate configuration descriptor
390 //
391 m_ConfigurationDescriptors = (PUSB_CONFIGURATION_DESCRIPTOR*) ExAllocatePoolWithTag(NonPagedPool, sizeof(PUSB_CONFIGURATION_DESCRIPTOR) * m_DeviceDescriptor.bNumConfigurations, TAG_USBOHCI);
392
393 //
394 // zero configuration descriptor
395 //
396 RtlZeroMemory(m_ConfigurationDescriptors, sizeof(PUSB_CONFIGURATION_DESCRIPTOR) * m_DeviceDescriptor.bNumConfigurations);
397
398 //
399 // retrieve the configuration descriptors
400 //
401 for(Index = 0; Index < m_DeviceDescriptor.bNumConfigurations; Index++)
402 {
403 //
404 // retrieve configuration descriptors from device
405 //
406 Status = CreateConfigurationDescriptor(Index);
407 if (!NT_SUCCESS(Status))
408 {
409 DPRINT1("CUSBDevice::SetDeviceAddress> failed to retrieve configuration %lu\n", Index);
410 break;
411 }
412 }
413
414 //
415 // done
416 //
417 return Status;
418
419 }
420
421 //----------------------------------------------------------------------------------------
422 void
423 CUSBDevice::GetDeviceDescriptor(
424 PUSB_DEVICE_DESCRIPTOR DeviceDescriptor)
425 {
426 RtlMoveMemory(DeviceDescriptor, &m_DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
427 }
428
429 //----------------------------------------------------------------------------------------
430 UCHAR
431 CUSBDevice::GetConfigurationValue()
432 {
433 //
434 // return configuration index
435 //
436 return m_ConfigurationIndex;
437 }
438
439 //----------------------------------------------------------------------------------------
440 NTSTATUS
441 CUSBDevice::CommitIrp(
442 PIRP Irp)
443 {
444 NTSTATUS Status;
445 PUSBREQUEST Request;
446
447 if (!m_Queue || !m_DmaManager)
448 {
449 //
450 // no queue, wtf?
451 //
452 DPRINT1("CUSBDevice::CommitUrb> no queue / dma !!!\n");
453 return STATUS_UNSUCCESSFUL;
454 }
455
456 //
457 // build usb request
458 //
459 Status = m_Queue->CreateUSBRequest(&Request);
460 if (!NT_SUCCESS(Status))
461 {
462 //
463 // failed to build request
464 //
465 DPRINT1("CUSBDevice::CommitSetupPacket> CreateUSBRequest failed with %x\n", Status);
466 return Status;
467 }
468
469 //
470 // initialize request
471 //
472 Status = Request->InitializeWithIrp(m_DmaManager, Irp, GetSpeed());
473
474 //
475 // mark irp as pending
476 //
477 IoMarkIrpPending(Irp);
478
479 //
480 // now add the request
481 //
482 Status = m_Queue->AddUSBRequest(Request);
483 if (!NT_SUCCESS(Status))
484 {
485 //
486 // failed to add request
487 //
488 DPRINT1("CUSBDevice::CommitSetupPacket> failed add request to queue with %x\n", Status);
489 Request->Release();
490 return Status;
491 }
492
493 //
494 // done
495 //
496 return STATUS_PENDING;
497 }
498
499 //----------------------------------------------------------------------------------------
500 NTSTATUS
501 CUSBDevice::SubmitIrp(
502 PIRP Irp)
503 {
504 KIRQL OldLevel;
505 NTSTATUS Status;
506
507 //
508 // acquire device lock
509 //
510 KeAcquireSpinLock(&m_Lock, &OldLevel);
511
512 //
513 // commit urb
514 //
515 Status = CommitIrp(Irp);
516
517 //
518 // release lock
519 //
520 KeReleaseSpinLock(&m_Lock, OldLevel);
521
522 return Status;
523 }
524 //----------------------------------------------------------------------------------------
525 NTSTATUS
526 CUSBDevice::CommitSetupPacket(
527 IN PUSB_DEFAULT_PIPE_SETUP_PACKET Packet,
528 IN OPTIONAL PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor,
529 IN ULONG BufferLength,
530 IN OUT PMDL Mdl)
531 {
532 NTSTATUS Status;
533 PUSBREQUEST Request;
534
535 if (!m_Queue)
536 {
537 //
538 // no queue, wtf?
539 //
540 DPRINT1("CUSBDevice::CommitSetupPacket> no queue!!!\n");
541 return STATUS_UNSUCCESSFUL;
542 }
543
544 //
545 // build usb request
546 //
547 Status = m_Queue->CreateUSBRequest(&Request);
548 if (!NT_SUCCESS(Status))
549 {
550 //
551 // failed to build request
552 //
553 DPRINT1("CUSBDevice::CommitSetupPacket> CreateUSBRequest failed with %x\n", Status);
554 return Status;
555 }
556
557 //
558 // initialize request
559 //
560 Status = Request->InitializeWithSetupPacket(m_DmaManager, Packet, m_DeviceAddress, EndpointDescriptor, GetSpeed(), BufferLength, Mdl);
561 if (!NT_SUCCESS(Status))
562 {
563 //
564 // failed to initialize request
565 //
566 DPRINT1("CUSBDevice::CommitSetupPacket> failed to initialize usb request with %x\n", Status);
567 Request->Release();
568 return Status;
569 }
570
571 //
572 // now add the request
573 //
574 Status = m_Queue->AddUSBRequest(Request);
575 if (!NT_SUCCESS(Status))
576 {
577 //
578 // failed to add request
579 //
580 DPRINT1("CUSBDevice::CommitSetupPacket> failed add request to queue with %x\n", Status);
581 Request->Release();
582 return Status;
583 }
584
585 //
586 // get the result code when the operation has been finished
587 //
588 Request->GetResultStatus(&Status, NULL);
589
590 //
591 // release request
592 //
593 Request->Release();
594
595 //
596 // done
597 //
598 return Status;
599 }
600
601 //----------------------------------------------------------------------------------------
602 NTSTATUS
603 CUSBDevice::CreateDeviceDescriptor()
604 {
605 USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
606 PMDL Mdl;
607 NTSTATUS Status;
608 PVOID DeviceDescriptor;
609
610 //
611 // allocate descriptor page aligned
612 //
613 DeviceDescriptor = ExAllocatePool(NonPagedPool, PAGE_SIZE);
614 if (!DeviceDescriptor)
615 {
616 //
617 // no memory
618 //
619 return STATUS_INSUFFICIENT_RESOURCES;
620 }
621
622 //
623 // zero descriptor
624 //
625 RtlZeroMemory(DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
626 RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
627
628 //
629 // setup request
630 //
631 CtrlSetup.bRequest = USB_REQUEST_GET_DESCRIPTOR;
632 CtrlSetup.wValue.HiByte = USB_DEVICE_DESCRIPTOR_TYPE;
633 CtrlSetup.wLength = sizeof(USB_DEVICE_DESCRIPTOR);
634 CtrlSetup.bmRequestType.B = 0x80;
635
636 //
637 // allocate mdl describing the device descriptor
638 //
639 Mdl = IoAllocateMdl(DeviceDescriptor, PAGE_SIZE, FALSE, FALSE, 0);
640 if (!Mdl)
641 {
642 //
643 // failed to allocate mdl
644 //
645 return STATUS_INSUFFICIENT_RESOURCES;
646 }
647
648 //
649 // build mdl for non paged pool
650 //
651 MmBuildMdlForNonPagedPool(Mdl);
652
653 //
654 // commit setup packet
655 //
656 Status = CommitSetupPacket(&CtrlSetup, 0, sizeof(USB_DEVICE_DESCRIPTOR), Mdl);
657
658 //
659 // now free the mdl
660 //
661 IoFreeMdl(Mdl);
662
663 if (NT_SUCCESS(Status))
664 {
665 //
666 // copy back device descriptor
667 //
668 RtlCopyMemory(&m_DeviceDescriptor, DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
669
670 //
671 // informal dbg print
672 //
673 DumpDeviceDescriptor(&m_DeviceDescriptor);
674 }
675
676 //
677 // free item
678 //
679 ExFreePool(DeviceDescriptor);
680
681 //
682 // done
683 //
684 return Status;
685
686 }
687
688 //----------------------------------------------------------------------------------------
689 NTSTATUS
690 CUSBDevice::CreateConfigurationDescriptor(
691 ULONG Index)
692 {
693 PVOID Buffer;
694 USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
695 NTSTATUS Status;
696 PMDL Mdl;
697 PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor;
698
699
700 //
701 // sanity checks
702 //
703 PC_ASSERT(m_ConfigurationDescriptors);
704
705 //
706 // first allocate a buffer which should be enough to store all different interfaces and endpoints
707 //
708 Buffer = ExAllocatePoolWithTag(NonPagedPool, PAGE_SIZE, TAG_USBOHCI);
709 if (!Buffer)
710 {
711 //
712 // failed to allocate buffer
713 //
714 return STATUS_INSUFFICIENT_RESOURCES;
715 }
716
717 //
718 // zero buffer
719 //
720 RtlZeroMemory(Buffer, PAGE_SIZE);
721
722 //
723 // build setup packet
724 //
725 CtrlSetup.bmRequestType._BM.Recipient = BMREQUEST_TO_DEVICE;
726 CtrlSetup.bmRequestType._BM.Type = BMREQUEST_STANDARD;
727 CtrlSetup.bmRequestType._BM.Reserved = 0;
728 CtrlSetup.bmRequestType._BM.Dir = BMREQUEST_DEVICE_TO_HOST;
729 CtrlSetup.bRequest = USB_REQUEST_GET_DESCRIPTOR;
730 CtrlSetup.wValue.LowByte = 0;
731 CtrlSetup.wValue.HiByte = USB_CONFIGURATION_DESCRIPTOR_TYPE;
732 CtrlSetup.wIndex.W = 0;
733 CtrlSetup.wLength = PAGE_SIZE;
734
735 //
736 // FIXME: where put configuration index?
737 //
738
739 //
740 // now build MDL describing the buffer
741 //
742 Mdl = IoAllocateMdl(Buffer, PAGE_SIZE, FALSE, FALSE, 0);
743 if (!Mdl)
744 {
745 //
746 // failed to allocate mdl
747 //
748 ExFreePoolWithTag(Buffer, TAG_USBOHCI);
749 return STATUS_INSUFFICIENT_RESOURCES;
750 }
751
752 //
753 // build mdl for non paged pool
754 //
755 MmBuildMdlForNonPagedPool(Mdl);
756
757 //
758 // commit packet
759 //
760 Status = CommitSetupPacket(&CtrlSetup, 0, PAGE_SIZE, Mdl);
761 if (!NT_SUCCESS(Status))
762 {
763 //
764 // failed to issue request, cleanup
765 //
766 IoFreeMdl(Mdl);
767 ExFreePool(Buffer);
768 return Status;
769 }
770
771 //
772 // now free the mdl
773 //
774 IoFreeMdl(Mdl);
775
776 //
777 // get configuration descriptor
778 //
779 ConfigurationDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)Buffer;
780
781 //
782 // informal debug print
783 //
784 DumpConfigurationDescriptor(ConfigurationDescriptor);
785
786 //
787 // sanity check
788 //
789 PC_ASSERT(ConfigurationDescriptor->bLength == sizeof(USB_CONFIGURATION_DESCRIPTOR));
790 PC_ASSERT(ConfigurationDescriptor->wTotalLength <= PAGE_SIZE);
791 PC_ASSERT(ConfigurationDescriptor->bNumInterfaces);
792
793 //
794 // store configuration descriptor
795 //
796 m_ConfigurationDescriptors[Index] = ConfigurationDescriptor;
797
798 //
799 // done
800 //
801 return Status;
802 }
803 //----------------------------------------------------------------------------------------
804 VOID
805 CUSBDevice::GetConfigurationDescriptors(
806 IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptorBuffer,
807 IN ULONG BufferLength,
808 OUT PULONG OutBufferLength)
809 {
810 //
811 // sanity check
812 //
813 PC_ASSERT(BufferLength >= sizeof(USB_CONFIGURATION_DESCRIPTOR));
814 PC_ASSERT(ConfigDescriptorBuffer);
815 PC_ASSERT(OutBufferLength);
816
817 //
818 // reset copied length
819 //
820 *OutBufferLength = 0;
821
822 //
823 // FIXME: support multiple configurations
824 //
825 PC_ASSERT(m_DeviceDescriptor.bNumConfigurations == 1);
826
827 //
828 // copy configuration descriptor
829 //
830 RtlCopyMemory(ConfigDescriptorBuffer, m_ConfigurationDescriptors[0], min(m_ConfigurationDescriptors[0]->wTotalLength, BufferLength));
831 *OutBufferLength = m_ConfigurationDescriptors[0]->wTotalLength;
832 }
833
834 //----------------------------------------------------------------------------------------
835 ULONG
836 CUSBDevice::GetConfigurationDescriptorsLength()
837 {
838 //
839 // FIXME: support multiple configurations
840 //
841 PC_ASSERT(m_DeviceDescriptor.bNumConfigurations == 1);
842
843 ASSERT(m_ConfigurationDescriptors[0]);
844 ASSERT(m_ConfigurationDescriptors[0]->wTotalLength);
845
846 return m_ConfigurationDescriptors[0]->wTotalLength;
847 }
848 //----------------------------------------------------------------------------------------
849 VOID
850 CUSBDevice::DumpDeviceDescriptor(PUSB_DEVICE_DESCRIPTOR DeviceDescriptor)
851 {
852 DPRINT1("Dumping Device Descriptor %x\n", DeviceDescriptor);
853 DPRINT1("bLength %x\n", DeviceDescriptor->bLength);
854 DPRINT1("bDescriptorType %x\n", DeviceDescriptor->bDescriptorType);
855 DPRINT1("bcdUSB %x\n", DeviceDescriptor->bcdUSB);
856 DPRINT1("bDeviceClass %x\n", DeviceDescriptor->bDeviceClass);
857 DPRINT1("bDeviceSubClass %x\n", DeviceDescriptor->bDeviceSubClass);
858 DPRINT1("bDeviceProtocol %x\n", DeviceDescriptor->bDeviceProtocol);
859 DPRINT1("bMaxPacketSize0 %x\n", DeviceDescriptor->bMaxPacketSize0);
860 DPRINT1("idVendor %x\n", DeviceDescriptor->idVendor);
861 DPRINT1("idProduct %x\n", DeviceDescriptor->idProduct);
862 DPRINT1("bcdDevice %x\n", DeviceDescriptor->bcdDevice);
863 DPRINT1("iManufacturer %x\n", DeviceDescriptor->iManufacturer);
864 DPRINT1("iProduct %x\n", DeviceDescriptor->iProduct);
865 DPRINT1("iSerialNumber %x\n", DeviceDescriptor->iSerialNumber);
866 DPRINT1("bNumConfigurations %x\n", DeviceDescriptor->bNumConfigurations);
867 }
868
869 //----------------------------------------------------------------------------------------
870 VOID
871 CUSBDevice::DumpConfigurationDescriptor(PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor)
872 {
873 DPRINT1("Dumping ConfigurationDescriptor %x\n", ConfigurationDescriptor);
874 DPRINT1("bLength %x\n", ConfigurationDescriptor->bLength);
875 DPRINT1("bDescriptorType %x\n", ConfigurationDescriptor->bDescriptorType);
876 DPRINT1("wTotalLength %x\n", ConfigurationDescriptor->wTotalLength);
877 DPRINT1("bNumInterfaces %x\n", ConfigurationDescriptor->bNumInterfaces);
878 DPRINT1("bConfigurationValue %x\n", ConfigurationDescriptor->bConfigurationValue);
879 DPRINT1("iConfiguration %x\n", ConfigurationDescriptor->iConfiguration);
880 DPRINT1("bmAttributes %x\n", ConfigurationDescriptor->bmAttributes);
881 DPRINT1("MaxPower %x\n", ConfigurationDescriptor->MaxPower);
882 }
883 //----------------------------------------------------------------------------------------
884 NTSTATUS
885 CUSBDevice::SubmitSetupPacket(
886 IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
887 IN OUT ULONG BufferLength,
888 OUT PVOID Buffer)
889 {
890 NTSTATUS Status;
891 PMDL Mdl = NULL;
892
893 if (BufferLength)
894 {
895 //
896 // allocate mdl
897 //
898 Mdl = IoAllocateMdl(Buffer, BufferLength, FALSE, FALSE, 0);
899 if (!Mdl)
900 return STATUS_INSUFFICIENT_RESOURCES;
901
902 //
903 // HACK HACK HACK: assume the buffer is build from non paged pool
904 //
905 MmBuildMdlForNonPagedPool(Mdl);
906 }
907
908 //
909 // commit setup packet
910 //
911 Status = CommitSetupPacket(SetupPacket, 0, BufferLength, Mdl);
912
913 if (Mdl != NULL)
914 {
915 //
916 // free mdl
917 //
918 IoFreeMdl(Mdl);
919 }
920
921 //
922 // done
923 //
924 return Status;
925 }
926
927 //----------------------------------------------------------------------------------------
928 NTSTATUS
929 CUSBDevice::SelectConfiguration(
930 IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
931 IN PUSBD_INTERFACE_INFORMATION InterfaceInfo,
932 OUT USBD_CONFIGURATION_HANDLE *ConfigurationHandle)
933 {
934 ULONG InterfaceIndex, PipeIndex;
935 USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
936 NTSTATUS Status;
937 PUSB_CONFIGURATION_DESCRIPTOR CurrentConfigurationDescriptor;
938 PUSB_INTERFACE_DESCRIPTOR CurrentInterfaceDescriptor;
939 PUSB_ENDPOINT_DESCRIPTOR CurrentEndpointDescriptor;
940 PVOID StartPosition;
941
942 //
943 // FIXME: support multiple configurations
944 //
945 ASSERT(m_DeviceDescriptor.bNumConfigurations == 1);
946 ASSERT(m_ConfigurationDescriptors[0]);
947 CurrentConfigurationDescriptor = m_ConfigurationDescriptors[0];
948
949 //
950 // sanity check
951 //
952 PC_ASSERT(ConfigurationDescriptor->iConfiguration == CurrentConfigurationDescriptor->iConfiguration);
953 PC_ASSERT(ConfigurationDescriptor->bNumInterfaces <= CurrentConfigurationDescriptor->bNumInterfaces);
954 DPRINT1("CUSBDevice::SelectConfiguration NumInterfaces %lu\n", ConfigurationDescriptor->bNumInterfaces);
955
956
957 //
958 // copy interface info and pipe info
959 //
960 for(InterfaceIndex = 0; InterfaceIndex < ConfigurationDescriptor->bNumInterfaces; InterfaceIndex++)
961 {
962 //
963 // find interface descriptor
964 //
965 CurrentInterfaceDescriptor = USBD_ParseConfigurationDescriptor(CurrentConfigurationDescriptor, InterfaceInfo->InterfaceNumber, InterfaceInfo->AlternateSetting);
966
967 //
968 // sanity check
969 //
970 ASSERT(CurrentInterfaceDescriptor);
971 ASSERT(CurrentInterfaceDescriptor->bLength != 0);
972 ASSERT(InterfaceInfo->NumberOfPipes == CurrentInterfaceDescriptor->bNumEndpoints);
973 ASSERT(InterfaceInfo->Length != 0);
974 #ifdef _MSC_VER
975 PC_ASSERT(InterfaceInfo->Length == FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes[InterfaceInfo->NumberOfPipes]));
976 #endif
977
978 DPRINT1("CUSBDevice::SelectConfiguration InterfaceNumber %lu AlternativeSetting %lu bNumEndpoints %lu\n", InterfaceInfo->InterfaceNumber, InterfaceInfo->AlternateSetting, CurrentInterfaceDescriptor->bNumEndpoints);
979
980 //
981 // copy interface info
982 //
983 InterfaceInfo->InterfaceHandle = (USBD_INTERFACE_HANDLE)CurrentInterfaceDescriptor;
984 InterfaceInfo->Class = CurrentInterfaceDescriptor->bInterfaceClass;
985 InterfaceInfo->SubClass = CurrentInterfaceDescriptor->bInterfaceSubClass;
986 InterfaceInfo->Protocol = CurrentInterfaceDescriptor->bInterfaceProtocol;
987 InterfaceInfo->Reserved = 0;
988
989 //
990 // copy endpoint info
991 //
992 StartPosition = CurrentInterfaceDescriptor;
993 for(PipeIndex = 0; PipeIndex < InterfaceInfo->NumberOfPipes; PipeIndex++)
994 {
995 //
996 // find corresponding endpoint descriptor
997 //
998 CurrentEndpointDescriptor = (PUSB_ENDPOINT_DESCRIPTOR)USBD_ParseDescriptors(CurrentConfigurationDescriptor, CurrentConfigurationDescriptor->wTotalLength, StartPosition, USB_ENDPOINT_DESCRIPTOR_TYPE);
999
1000 //
1001 // sanity checks
1002 //
1003 ASSERT(CurrentEndpointDescriptor);
1004 ASSERT(CurrentEndpointDescriptor->bDescriptorType == USB_ENDPOINT_DESCRIPTOR_TYPE);
1005
1006 //
1007 // copy pipe info
1008 //
1009 InterfaceInfo->Pipes[PipeIndex].MaximumPacketSize = CurrentEndpointDescriptor->wMaxPacketSize;
1010 InterfaceInfo->Pipes[PipeIndex].EndpointAddress = CurrentEndpointDescriptor->bEndpointAddress;
1011 InterfaceInfo->Pipes[PipeIndex].Interval = CurrentEndpointDescriptor->bInterval;
1012 InterfaceInfo->Pipes[PipeIndex].PipeType = (USBD_PIPE_TYPE)CurrentEndpointDescriptor->bmAttributes;
1013 InterfaceInfo->Pipes[PipeIndex].PipeHandle = (PVOID)CurrentEndpointDescriptor;
1014
1015 //
1016 // move start position beyond the current endpoint descriptor
1017 //
1018 StartPosition = (PVOID)(CurrentEndpointDescriptor + 1);
1019 }
1020
1021 //
1022 // move offset
1023 //
1024 InterfaceInfo = (PUSBD_INTERFACE_INFORMATION)((ULONG_PTR)PtrToUlong(InterfaceInfo) + InterfaceInfo->Length);
1025 }
1026
1027 //
1028 // now build setup packet
1029 //
1030 RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
1031 CtrlSetup.bRequest = USB_REQUEST_SET_CONFIGURATION;
1032 CtrlSetup.wValue.W = ConfigurationDescriptor->bConfigurationValue;
1033
1034 //
1035 // select configuration
1036 //
1037 Status = CommitSetupPacket(&CtrlSetup, 0, 0, 0);
1038
1039 //
1040 // informal debug print
1041 //
1042 DPRINT1("CUsbDevice::SelectConfiguration New Configuration %x Old Configuration %x Result %x\n", ConfigurationDescriptor->iConfiguration, m_ConfigurationIndex, Status);
1043
1044 if (NT_SUCCESS(Status))
1045 {
1046 //
1047 // store configuration device index
1048 //
1049 m_ConfigurationIndex = ConfigurationDescriptor->iConfiguration;
1050
1051 //
1052 // store configuration handle
1053 //
1054 *ConfigurationHandle = m_ConfigurationDescriptors[0];
1055 }
1056
1057 //
1058 // done
1059 //
1060 return Status;
1061 }
1062
1063 //----------------------------------------------------------------------------------------
1064 NTSTATUS
1065 CUSBDevice::SelectInterface(
1066 IN USBD_CONFIGURATION_HANDLE ConfigurationHandle,
1067 IN OUT PUSBD_INTERFACE_INFORMATION InterfaceInfo)
1068 {
1069 PUSB_CONFIGURATION_DESCRIPTOR Configuration;
1070 ULONG PipeIndex;
1071 USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
1072 NTSTATUS Status;
1073 PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
1074 PUSB_ENDPOINT_DESCRIPTOR CurrentEndpointDescriptor;
1075 PVOID StartPosition;
1076
1077 //
1078 // FIXME support multiple configurations
1079 //
1080 PC_ASSERT(m_ConfigurationDescriptors[0] == (PUSB_CONFIGURATION_DESCRIPTOR)ConfigurationHandle);
1081
1082 //
1083 // get configuration struct
1084 //
1085 Configuration = (PUSB_CONFIGURATION_DESCRIPTOR)ConfigurationHandle;
1086
1087 //
1088 // sanity checks
1089 //
1090 PC_ASSERT(Configuration->bNumInterfaces > InterfaceInfo->InterfaceNumber);
1091 #ifdef _MSC_VER
1092 //PC_ASSERT(InterfaceInfo->Length == FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes[InterfaceInfo->NumberOfPipes]));
1093 #endif
1094
1095 //
1096 // FIXME: check bandwidth
1097 //
1098
1099 //
1100 // find interface number
1101 //
1102 InterfaceDescriptor = USBD_ParseConfigurationDescriptor(Configuration, InterfaceInfo->InterfaceNumber, InterfaceInfo->AlternateSetting);
1103 ASSERT(InterfaceDescriptor);
1104
1105 //
1106 // initialize setup packet
1107 //
1108 RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
1109 CtrlSetup.bRequest = USB_REQUEST_SET_INTERFACE;
1110 CtrlSetup.wValue.W = InterfaceDescriptor->bAlternateSetting;
1111 CtrlSetup.wIndex.W = InterfaceDescriptor->bInterfaceNumber;
1112 CtrlSetup.bmRequestType.B = 0x01;
1113
1114 //
1115 // issue request
1116 //
1117 Status = CommitSetupPacket(&CtrlSetup, 0, 0, 0);
1118
1119 //
1120 // informal debug print
1121 //
1122 DPRINT1("CUSBDevice::SelectInterface AlternateSetting %x InterfaceNumber %x Status %x\n", InterfaceInfo->AlternateSetting, InterfaceInfo->InterfaceNumber, Status);
1123 DPRINT1("CUSBDevice::SelectInterface bInterfaceNumber %u bAlternateSetting %u NumberOfPipes %u Length %lu\n",
1124 InterfaceDescriptor->bInterfaceNumber, InterfaceDescriptor->bAlternateSetting, InterfaceInfo->NumberOfPipes, InterfaceInfo->Length);
1125 InterfaceInfo->InterfaceHandle = InterfaceDescriptor;
1126 InterfaceInfo->NumberOfPipes = InterfaceDescriptor->bNumEndpoints;
1127
1128 //
1129 // are there end points
1130 //
1131 if (InterfaceDescriptor->bNumEndpoints)
1132 {
1133 //
1134 // sanity check
1135 //
1136 ASSERT(InterfaceInfo->Length == sizeof(USBD_INTERFACE_INFORMATION) + (InterfaceDescriptor->bNumEndpoints > 1 ? sizeof(USBD_PIPE_INFORMATION) * (InterfaceDescriptor->bNumEndpoints - 1) : 0));
1137
1138 //
1139 // store number of pipes
1140 //
1141 InterfaceInfo->NumberOfPipes = InterfaceDescriptor->bNumEndpoints;
1142
1143 StartPosition = InterfaceDescriptor;
1144 for(PipeIndex = 0; PipeIndex < InterfaceInfo->NumberOfPipes; PipeIndex++)
1145 {
1146 //
1147 // find corresponding endpoint descriptor
1148 //
1149 CurrentEndpointDescriptor = (PUSB_ENDPOINT_DESCRIPTOR)USBD_ParseDescriptors(Configuration, Configuration->wTotalLength, StartPosition, USB_ENDPOINT_DESCRIPTOR_TYPE);
1150
1151 //
1152 // sanity checks
1153 //
1154 ASSERT(CurrentEndpointDescriptor);
1155 ASSERT(CurrentEndpointDescriptor->bDescriptorType == USB_ENDPOINT_DESCRIPTOR_TYPE);
1156
1157 //
1158 // copy pipe info
1159 //
1160 InterfaceInfo->Pipes[PipeIndex].MaximumPacketSize = CurrentEndpointDescriptor->wMaxPacketSize;
1161 InterfaceInfo->Pipes[PipeIndex].EndpointAddress = CurrentEndpointDescriptor->bEndpointAddress;
1162 InterfaceInfo->Pipes[PipeIndex].Interval = CurrentEndpointDescriptor->bInterval;
1163 InterfaceInfo->Pipes[PipeIndex].PipeType = (USBD_PIPE_TYPE)CurrentEndpointDescriptor->bmAttributes;
1164 InterfaceInfo->Pipes[PipeIndex].PipeHandle = (PVOID)CurrentEndpointDescriptor;
1165
1166 //
1167 // move start position beyond the current endpoint descriptor
1168 //
1169 StartPosition = (PVOID)(CurrentEndpointDescriptor + 1);
1170 }
1171 }
1172 //
1173 // done
1174 //
1175 return Status;
1176 }
1177
1178 NTSTATUS
1179 CUSBDevice::AbortPipe(
1180 IN PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor)
1181 {
1182 //
1183 // let it handle usb queue
1184 //
1185 ASSERT(m_Queue);
1186 ASSERT(m_DeviceAddress);
1187
1188 //
1189 // done
1190 //
1191 return m_Queue->AbortDevicePipe(m_DeviceAddress, EndpointDescriptor);
1192 }
1193
1194 //----------------------------------------------------------------------------------------
1195 NTSTATUS
1196 CreateUSBDevice(
1197 PUSBDEVICE *OutDevice)
1198 {
1199 CUSBDevice * This;
1200
1201 //
1202 // allocate controller
1203 //
1204 This = new(NonPagedPool, TAG_USBOHCI) CUSBDevice(0);
1205 if (!This)
1206 {
1207 //
1208 // failed to allocate
1209 //
1210 return STATUS_INSUFFICIENT_RESOURCES;
1211 }
1212
1213 //
1214 // add reference count
1215 //
1216 This->AddRef();
1217
1218 //
1219 // return result
1220 //
1221 *OutDevice = (PUSBDEVICE)This;
1222
1223 //
1224 // done
1225 //
1226 return STATUS_SUCCESS;
1227 }
1228