e7920e2c77e5b9168e9546931c4727f1f65fa0ce
[reactos.git] / drivers / usb / usbohci / interfaces.h
1
2 #ifndef INTERFACES_HPP
3 #define INTERFACES_HPP
4
5 //---------------------------------------------------------------------------
6 //
7 // Object Hierachy
8 // --------------------------------------------------------------------
9 // | IRootHCDController |
10 // | IHCDController Intel USB Universal Host Controller - 3A37 |
11 // | IHCDController - Intel USB Universal HostController - 3A38 |
12 // | IHCDController - Intel USB Universal HostController - 3A38 |
13 // |------------------------------------------------------------------|
14 //
15 //
16 // IHCDController Intel USB Universal Host Controller - 3A37
17 // IHubController
18 // IUSBHardwareDevice
19 // IDMAMemoryManager
20 // IUSBQueue <- interacts with -> IUSBRequest
21 //
22 //
23 // Each IHCDController creates an IUSBHardwareDevice class upon initialization. The
24 // IUSBHardwardeDevice class is used to abstract usb controller specifics. The IHubController
25 // manages all attached devices and handles hub control ioctl requests.
26 //
27 // Each IUSBHardwareDevice has one IDMAMemoryManager and one IUSBQueue. The IDMAMemoryManager
28 // is used to handle dma memory allocations. The IUSBQueue manages requests which are send to the
29 // usb hardware. See IUSBRequest class for details.
30 //
31
32
33 //=========================================================================================
34 //
35 // class IRootHCDController
36 //
37 // Description: This class serves as the root host controller. The host controller mantains
38 // a list of registered controllers and provides support functions for the host controllers
39
40 struct IHCDController;
41
42 DECLARE_INTERFACE_(IRootHCDController, IUnknown)
43 {
44 DEFINE_ABSTRACT_UNKNOWN()
45
46 //-----------------------------------------------------------------------------------------
47 //
48 // Initialize
49 //
50 // Description: This function initializes the root host controller. It allocates the resources
51 // required to manage the registered controllers
52
53 virtual NTSTATUS Initialize() = 0;
54
55 //-----------------------------------------------------------------------------------------
56 //
57 // RegisterHCD
58 //
59 // Description: this function registers a host controller with the root host controller
60
61 virtual NTSTATUS RegisterHCD(struct IHCDController * Controller) = 0;
62
63 //-----------------------------------------------------------------------------------------
64 //
65 // UnregisterHCD
66 //
67 // Description: this function unregistes a host controller
68
69 virtual NTSTATUS UnregisterHCD(struct IHCDController * Controller) = 0;
70
71 //-----------------------------------------------------------------------------------------
72 //
73 // GetControllerCount
74 //
75 // Description: returns the number of host controllers registered
76
77 virtual ULONG GetControllerCount() = 0;
78
79 };
80
81 typedef IRootHCDController *PROOTHDCCONTROLLER;
82
83 //=========================================================================================
84 //
85 // class IHCDController
86 //
87 // Description: This class is used to manage a single USB host controller
88 //
89
90 DECLARE_INTERFACE_(IHCDController, IUnknown)
91 {
92 DEFINE_ABSTRACT_UNKNOWN()
93
94 //-----------------------------------------------------------------------------------------
95 //
96 // Initialize
97 //
98 // Description: This function initializes the IHCDController implementation.
99 // It creates an IUSBHardwareDevice object and initializes it. It also registeres itself with
100 // the IRootHCDController
101 //
102 virtual NTSTATUS Initialize(IN PROOTHDCCONTROLLER RootHCDController,
103 IN PDRIVER_OBJECT DriverObject,
104 IN PDEVICE_OBJECT PhysicalDeviceObject) = 0;
105
106 };
107
108 typedef IHCDController *PHCDCONTROLLER;
109
110 struct _OHCI_ENDPOINT_DESCRIPTOR;
111 //=========================================================================================
112 //
113 // class IUSBHardwareDevice
114 //
115 // Description: This class provides access to the usb hardware controller
116 //
117
118 struct IDMAMemoryManager;
119 struct IUSBQueue;
120
121 DECLARE_INTERFACE_(IUSBHardwareDevice, IUnknown)
122 {
123 DEFINE_ABSTRACT_UNKNOWN()
124
125 //-----------------------------------------------------------------------------------------
126 //
127 // Initialize
128 //
129 // Description: Initializes the usb device controller
130
131 virtual NTSTATUS Initialize(PDRIVER_OBJECT DriverObject,
132 PDEVICE_OBJECT FunctionalDeviceObject,
133 PDEVICE_OBJECT PhysicalDeviceObject,
134 PDEVICE_OBJECT LowerDeviceObject) = 0;
135
136 //-----------------------------------------------------------------------------------------
137 //
138 // PnpStart
139 //
140 // Description: handles pnp start request from device. It registeres the interrupt,
141 // sets up the ports and prepares the device. It then starts the controller
142
143 virtual NTSTATUS PnpStart(PCM_RESOURCE_LIST RawResources,
144 PCM_RESOURCE_LIST TranslatedResources) = 0;
145
146 //-----------------------------------------------------------------------------------------
147 //
148 // PnpStop
149 //
150 // Description: handles pnp stop request from device. It unregisteres the interrupt, releases ports and dma object.
151
152 virtual NTSTATUS PnpStop(void) = 0;
153
154 //-----------------------------------------------------------------------------------------
155 //
156 // GetDeviceDetails
157 //
158 // Description: returns the device details such as vendor id, device id, number of ports and speed
159
160 virtual NTSTATUS GetDeviceDetails(OUT OPTIONAL PUSHORT VendorId,
161 OUT OPTIONAL PUSHORT DeviceId,
162 OUT OPTIONAL PULONG NumberOfPorts,
163 OUT OPTIONAL PULONG Speed) = 0;
164
165 //-----------------------------------------------------------------------------------------
166 //
167 // GetUSBQueue
168 //
169 // Description: returns interface to internal IUSBQueue
170 // Interface is reference counted, you need to call release method when you are done with it
171 // Do not call Initialize on IUSBQueue, the object is already initialized
172
173 virtual NTSTATUS GetUSBQueue(OUT struct IUSBQueue **OutUsbQueue) = 0;
174
175 //-----------------------------------------------------------------------------------------
176 //
177 // GetBulkHeadEndpointDescriptor
178 //
179 // Description: returns the bulk head endpoint descriptor
180
181 virtual NTSTATUS GetBulkHeadEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor) = 0;
182
183 //-----------------------------------------------------------------------------------------
184 //
185 // GetControlHeadEndpointDescriptor
186 //
187 // Description: returns the control head endpoint descriptor
188
189 virtual NTSTATUS GetControlHeadEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor) = 0;
190
191 //-----------------------------------------------------------------------------------------
192 //
193 // GetIsochronousHeadEndpointDescriptor
194 //
195 // Description: returns the control head endpoint descriptor
196
197 virtual NTSTATUS GetIsochronousHeadEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor) = 0;
198
199
200 //-----------------------------------------------------------------------------------------
201 //
202 // GetInterruptEndpointDescriptors
203 //
204 // Description: returns interrupt endpoint descriptors
205
206 virtual NTSTATUS GetInterruptEndpointDescriptors(struct _OHCI_ENDPOINT_DESCRIPTOR *** OutDescriptorArray) = 0;
207
208 //-----------------------------------------------------------------------------------------
209 //
210 // HeadEndpointDescriptorModified
211 //
212 // Description: notifies the hardware that an endpoint descriptor was added to head endpoint descriptor
213
214 virtual VOID HeadEndpointDescriptorModified(ULONG HeadType) = 0;
215
216
217
218
219 //-----------------------------------------------------------------------------------------
220 //
221 // GetDMA
222 //
223 // Description: returns the DMA object which can be used to allocate memory from the common buffer
224
225 virtual NTSTATUS GetDMA(OUT struct IDMAMemoryManager **OutDMAMemoryManager) = 0;
226
227
228 //-----------------------------------------------------------------------------------------
229 //
230 // ResetController()
231 //
232 // Description: this function resets the controller
233 // Returns STATUS_SUCCESS when the controller was successfully reset
234
235 virtual NTSTATUS ResetController() = 0;
236
237 //-----------------------------------------------------------------------------------------
238 //
239 // StartController
240 //
241 // Description: this functions starts controller allowing interrupts for device connects/removal, and execution of
242 // Periodic and Asynchronous Schedules.
243 //
244
245 virtual NTSTATUS StartController() = 0;
246
247 //-----------------------------------------------------------------------------------------
248 //
249 // StopController
250 //
251 // Description: this functions stops controller disabling interrupts for device connects/removal, and execution of
252 // Periodic and Asynchronous Schedules.
253 //
254
255 virtual NTSTATUS StopController() = 0;
256
257 //-----------------------------------------------------------------------------------------
258 //
259 // ResetPort
260 //
261 // Description: this functions resets the port on the controller
262 //
263
264 virtual NTSTATUS ResetPort(ULONG PortNumber) = 0;
265
266 //-----------------------------------------------------------------------------------------
267 //
268 // GetPortStatus
269 //
270 // Description: this functions return status and change state of port
271 //
272 virtual NTSTATUS GetPortStatus(ULONG PortId, OUT USHORT *PortStatus, OUT USHORT *PortChange) = 0;
273
274 //-----------------------------------------------------------------------------------------
275 //
276 // ClearPortStatus
277 //
278 // Description: Clears Status of Port, for example Connection, Enable and Reset
279 //
280 virtual NTSTATUS ClearPortStatus(ULONG PortId, ULONG Status) = 0;
281
282 //-----------------------------------------------------------------------------------------
283 //
284 // SetPortFeature
285 //
286 // Description: this functions Sets Feature on Port, for example Enable, Power and Reset
287 //
288 virtual NTSTATUS SetPortFeature(ULONG PortId, ULONG Feature) = 0;
289
290 //-----------------------------------------------------------------------------------------
291 //
292 // SetStatusChangeEndpointCallBack
293 //
294 // Description: Used to callback to the hub controller when SCE detected
295 //
296 virtual VOID SetStatusChangeEndpointCallBack(PVOID CallBack,PVOID Context) = 0;
297
298 //-----------------------------------------------------------------------------------------
299 //
300 // AcquireDeviceLock
301 //
302 // Description: acquires the device lock
303
304 virtual KIRQL AcquireDeviceLock(void) = 0;
305
306 //-----------------------------------------------------------------------------------------
307 //
308 // ReleaseLock
309 //
310 // Description: releases the device lock
311
312 virtual void ReleaseDeviceLock(KIRQL OldLevel) = 0;
313
314 //----------------------------------------------------------------------------------------
315 //
316 // GetCurrentFrameNumber
317 //
318 // Description: returns the current frame number
319
320 virtual VOID GetCurrentFrameNumber(PULONG FrameNumber) = 0;
321 };
322
323 typedef IUSBHardwareDevice *PUSBHARDWAREDEVICE;
324
325
326 //=========================================================================================
327 //
328 // class IDMAMemoryManager
329 //
330 // Description: This class provides access to the dma buffer. It provides methods to
331 // allocate and free from the dma buffer
332 //
333
334 DECLARE_INTERFACE_(IDMAMemoryManager, IUnknown)
335 {
336 DEFINE_ABSTRACT_UNKNOWN()
337
338 //-----------------------------------------------------------------------------------------
339 //
340 // Initialize
341 //
342 // Description: initializes the memory manager
343
344 virtual NTSTATUS Initialize(IN PUSBHARDWAREDEVICE Device,
345 IN PKSPIN_LOCK Lock,
346 IN ULONG DmaBufferSize,
347 IN PVOID VirtualBase,
348 IN PHYSICAL_ADDRESS PhysicalAddress,
349 IN ULONG DefaultBlockSize) = 0;
350
351 //-----------------------------------------------------------------------------------------
352 //
353 // Allocate
354 //
355 // Description: allocates block of memory from allocator
356
357 virtual NTSTATUS Allocate(IN ULONG Size,
358 OUT PVOID *OutVirtualBase,
359 OUT PPHYSICAL_ADDRESS OutPhysicalAddress) = 0;
360
361
362 //-----------------------------------------------------------------------------------------
363 //
364 // Free
365 //
366 // Description: releases memory block
367
368 virtual NTSTATUS Release(IN PVOID VirtualBase,
369 IN ULONG Size) = 0;
370
371 };
372
373 typedef IDMAMemoryManager *PDMAMEMORYMANAGER;
374
375
376 //=========================================================================================
377 //
378 // class IUSBRequest
379 //
380 // Description: This class is used to issue request to usb controller. The class is
381 // initialized using InitializeXXX methods. You also need to call SetEndpoint to define the endpoint
382 // In addition you can call SetCompletionDetails if you need to wait for the end of
383 // the request or want to complete an irp. You call AddUSBRequest to add the request to the queue.
384 // Once the request is completed the CompletionCallback is invoked. The CompletionCallback
385 // will take care of any completion details which have been set. If the request is cancelled, the
386 // CancelCallback routine is invoked.
387 //
388
389 DECLARE_INTERFACE_(IUSBRequest, IUnknown)
390 {
391 DEFINE_ABSTRACT_UNKNOWN()
392
393 //-----------------------------------------------------------------------------------------
394 //
395 // InitializeWithSetupPacket
396 //
397 // Description: initializes the request packet with an setup packet
398 // If there is a TransferBuffer, the TransferBufferLength contains the length of the buffer
399
400
401 virtual NTSTATUS InitializeWithSetupPacket(IN PDMAMEMORYMANAGER DmaManager,
402 IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
403 IN UCHAR DeviceAddress,
404 IN OPTIONAL PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor,
405 IN OUT ULONG TransferBufferLength,
406 IN OUT PMDL TransferBuffer) = 0;
407
408 //-----------------------------------------------------------------------------------------
409 //
410 // InitializeWithIrp
411 //
412 // Description: initializes the request with an IRP
413 // The irp contains an URB block which contains all necessary information
414
415 virtual NTSTATUS InitializeWithIrp(IN PDMAMEMORYMANAGER DmaManager,
416 IN OUT PIRP Irp) = 0;
417
418 //-----------------------------------------------------------------------------------------
419 //
420 // IsRequestComplete
421 //
422 // Description: returns true when the request has been completed
423 // Should be called after the CompletionCallback has been invoked
424 // This function is called by IUSBQueue after queue head has been completed
425 // If the function returns true, IUSBQueue will then call ShouldReleaseRequestAfterCompletion
426 // If that function returns also true, it calls Release() to delete the IUSBRequest
427
428 virtual BOOLEAN IsRequestComplete() = 0;
429
430 //-----------------------------------------------------------------------------------------
431 //
432 // GetTransferType
433 //
434 // Description: returns the type of the request: control, bulk, iso, interrupt
435
436 virtual ULONG GetTransferType() = 0;
437
438 //-----------------------------------------------------------------------------------------
439 //
440 // GetEndpointDescriptor
441 //
442 // Description: returns the general transfer descriptor
443
444 virtual NTSTATUS GetEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor) = 0;
445
446 //-----------------------------------------------------------------------------------------
447 //
448 // GetResultStatus
449 //
450 // Description: returns the status code of the result
451 // Note: this function will block the caller untill the request has been completed
452
453 virtual VOID GetResultStatus(OUT OPTIONAL NTSTATUS * NtStatusCode,
454 OUT OPTIONAL PULONG UrbStatusCode) = 0;
455
456 //-----------------------------------------------------------------------------------------
457 //
458 // IsRequestInitialized
459 //
460 // Description: returns true when the request has been successfully initialized using InitializeXXX methods
461
462 virtual BOOLEAN IsRequestInitialized() = 0;
463
464 //-----------------------------------------------------------------------------------------
465 //
466 // CompletionCallback
467 //
468 // Description: notifies request that the endpoint descriptor is complete
469
470 virtual VOID CompletionCallback(struct _OHCI_ENDPOINT_DESCRIPTOR * OutDescriptor) = 0;
471
472 //-----------------------------------------------------------------------------------------
473 //
474 // FreeEndpointDescriptor
475 //
476 // Description: frees the associated endpoint descriptor and its general descriptors
477
478 virtual VOID FreeEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR * OutDescriptor) = 0;
479
480 //-----------------------------------------------------------------------------------------
481 //
482 // GetInterruptInterval
483 //
484 // Description: returns interval of the iso / interrupt
485
486 virtual UCHAR GetInterval() = 0;
487
488 };
489
490
491 typedef IUSBRequest *PUSBREQUEST;
492
493 //=========================================================================================
494 //
495 // class IUSBQueue
496 //
497 // Description: This class manages pending requests
498 //
499
500 DECLARE_INTERFACE_(IUSBQueue, IUnknown)
501 {
502 DEFINE_ABSTRACT_UNKNOWN()
503
504 //-----------------------------------------------------------------------------------------
505 //
506 // Initialize
507 //
508 // Description: initializes the object
509
510 virtual NTSTATUS Initialize(IN PUSBHARDWAREDEVICE Hardware,
511 IN PDMA_ADAPTER AdapterObject,
512 IN PDMAMEMORYMANAGER MemManager,
513 IN OPTIONAL PKSPIN_LOCK Lock) = 0;
514
515 //-----------------------------------------------------------------------------------------
516 //
517 // GetPendingRequestCount
518 //
519 // Description: returns the number of pending requests true from IsRequestComplete
520
521 virtual ULONG GetPendingRequestCount() = 0;
522
523 //-----------------------------------------------------------------------------------------
524 //
525 // AddUSBRequest
526 //
527 // Description: adds an usb request to the queue.
528 // Returns status success when successful
529
530 virtual NTSTATUS AddUSBRequest(IUSBRequest * Request) = 0;
531
532 //-----------------------------------------------------------------------------------------
533 //
534 // CancelRequests()
535 //
536 // Description: cancels all requests
537
538 virtual NTSTATUS CancelRequests() = 0;
539
540 //-----------------------------------------------------------------------------------------
541 //
542 // CreateUSBRequest
543 //
544 // Description: creates an usb request
545
546 virtual NTSTATUS CreateUSBRequest(IUSBRequest **OutRequest) = 0;
547
548 //-----------------------------------------------------------------------------------------
549 //
550 // TransferDescriptorCompletionCallback
551 //
552 // Description: notifies the queue that a transfer was completed
553
554 virtual VOID TransferDescriptorCompletionCallback(ULONG TransferDescriptorLogicalAddress) = 0;
555
556 };
557
558 typedef IUSBQueue *PUSBQUEUE;
559
560 //=========================================================================================
561 //
562 // class IHubController
563 //
564 // Description: This class implements a hub controller
565 //
566
567 DECLARE_INTERFACE_(IHubController, IUnknown)
568 {
569 DEFINE_ABSTRACT_UNKNOWN()
570
571 //----------------------------------------------------------------------------------------
572 //
573 // Initialize
574 //
575 // Description: Initializes the hub controller
576
577 virtual NTSTATUS Initialize(IN PDRIVER_OBJECT DriverObject,
578 IN PHCDCONTROLLER Controller,
579 IN PUSBHARDWAREDEVICE Device,
580 IN BOOLEAN IsRootHubDevice,
581 IN ULONG DeviceAddress) = 0;
582
583 //----------------------------------------------------------------------------------------
584 //
585 // GetHubControllerDeviceObject
586 //
587 // Description: Returns the hub controller device object
588
589 virtual NTSTATUS GetHubControllerDeviceObject(PDEVICE_OBJECT * HubDeviceObject) = 0;
590
591 //----------------------------------------------------------------------------------------
592 //
593 // GetHubControllerSymbolicLink
594 //
595 // Description: Returns the symbolic link of the root hub
596
597 virtual NTSTATUS GetHubControllerSymbolicLink(ULONG BufferLength, PVOID Buffer, PULONG RequiredLength) = 0;
598
599
600 };
601
602 typedef IHubController *PHUBCONTROLLER;
603
604 //=========================================================================================
605 //
606 // class IDispatchIrp
607 //
608 // Description: This class is used to handle irp dispatch requests
609 //
610
611 DECLARE_INTERFACE_(IDispatchIrp, IUnknown)
612 {
613 DEFINE_ABSTRACT_UNKNOWN()
614
615 //-----------------------------------------------------------------------------------------
616 //
617 // HandlePnp
618 //
619 // Description: This function handles all pnp requests
620
621 virtual NTSTATUS HandlePnp(IN PDEVICE_OBJECT DeviceObject,
622 IN OUT PIRP Irp) = 0;
623
624 //-----------------------------------------------------------------------------------------
625 //
626 // HandlePower
627 //
628 // Description: This function handles all power pnp requests
629 //
630 virtual NTSTATUS HandlePower(IN PDEVICE_OBJECT DeviceObject,
631 IN OUT PIRP Irp) = 0;
632
633 //-----------------------------------------------------------------------------------------
634 //
635 // HandleDeviceControl
636 //
637 // Description: handles device io control requests
638
639 virtual NTSTATUS HandleDeviceControl(IN PDEVICE_OBJECT DeviceObject,
640 IN OUT PIRP Irp) = 0;
641 };
642
643 typedef IDispatchIrp *PDISPATCHIRP;
644
645 //=========================================================================================
646 //
647 // class IUSBDevice
648 //
649 // Description: This class is used to abstract details of a usb device
650 //
651
652 DECLARE_INTERFACE_(IUSBDevice, IUnknown)
653 {
654 DEFINE_ABSTRACT_UNKNOWN()
655
656 //----------------------------------------------------------------------------------------
657 //
658 // Initialize
659 //
660 // Description: Initializes the usb device
661
662 virtual NTSTATUS Initialize(IN PHUBCONTROLLER HubController,
663 IN PUSBHARDWAREDEVICE Device,
664 IN PVOID Parent,
665 IN ULONG Port,
666 IN ULONG PortStatus) = 0;
667
668 //-----------------------------------------------------------------------------------------
669 //
670 // IsHub
671 //
672 // Description: returns true when device is a hub
673
674 virtual BOOLEAN IsHub() = 0;
675
676 //-----------------------------------------------------------------------------------------
677 //
678 // GetParent
679 //
680 // Description: gets the parent device of the this device
681
682 virtual NTSTATUS GetParent(PVOID * Parent) = 0;
683
684 //-----------------------------------------------------------------------------------------
685 //
686 // GetDeviceAddress
687 //
688 // Description: gets the device address of the this device
689
690 virtual UCHAR GetDeviceAddress() = 0;
691
692
693 //-----------------------------------------------------------------------------------------
694 //
695 // GetPort
696 //
697 // Description: gets the port to which this device is connected
698
699 virtual ULONG GetPort() = 0;
700
701 //-----------------------------------------------------------------------------------------
702 //
703 // GetSpeed
704 //
705 // Description: gets the speed of the device
706
707 virtual USB_DEVICE_SPEED GetSpeed() = 0;
708
709 //-----------------------------------------------------------------------------------------
710 //
711 // GetType
712 //
713 // Description: gets the type of the device, either 1.1 or 2.0 device
714
715 virtual USB_DEVICE_TYPE GetType() = 0;
716
717 //-----------------------------------------------------------------------------------------
718 //
719 // GetState
720 //
721 // Description: gets the device state
722
723 virtual ULONG GetState() = 0;
724
725 //-----------------------------------------------------------------------------------------
726 //
727 // SetDeviceHandleData
728 //
729 // Description: sets device handle data
730
731 virtual void SetDeviceHandleData(PVOID Data) = 0;
732
733 //-----------------------------------------------------------------------------------------
734 //
735 // SetDeviceAddress
736 //
737 // Description: sets device handle data
738
739 virtual NTSTATUS SetDeviceAddress(UCHAR DeviceAddress) = 0;
740
741 //-----------------------------------------------------------------------------------------
742 //
743 // GetDeviceDescriptor
744 //
745 // Description: sets device handle data
746
747 virtual void GetDeviceDescriptor(PUSB_DEVICE_DESCRIPTOR DeviceDescriptor) = 0;
748
749 //-----------------------------------------------------------------------------------------
750 //
751 // GetConfigurationValue
752 //
753 // Description: gets current selected configuration index
754
755 virtual UCHAR GetConfigurationValue() = 0;
756
757 //-----------------------------------------------------------------------------------------
758 //
759 // SubmitIrp
760 //
761 // Description: submits an irp containing an urb
762
763 virtual NTSTATUS SubmitIrp(PIRP Irp) = 0;
764
765 //-----------------------------------------------------------------------------------------
766 //
767 // GetConfigurationDescriptors
768 //
769 // Description: returns one or more configuration descriptors
770
771 virtual VOID GetConfigurationDescriptors(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptorBuffer,
772 IN ULONG BufferLength,
773 OUT PULONG OutBufferLength) = 0;
774
775 //-----------------------------------------------------------------------------------------
776 //
777 // Description: returns length of configuration descriptors
778 //
779 virtual ULONG GetConfigurationDescriptorsLength() = 0;
780
781 //-----------------------------------------------------------------------------------------
782 //
783 // SubmitSetupPacket
784 //
785 // Description: submits an setup packet. The usb device will then create an usb request from it and submit it to the queue
786
787 virtual NTSTATUS SubmitSetupPacket(IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
788 IN OUT ULONG BufferLength,
789 OUT PVOID Buffer) = 0;
790
791 //-----------------------------------------------------------------------------------------
792 //
793 // SelectConfiguration
794 //
795 // Description: selects a configuration
796
797 virtual NTSTATUS SelectConfiguration(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
798 IN PUSBD_INTERFACE_INFORMATION Interface,
799 OUT USBD_CONFIGURATION_HANDLE *ConfigurationHandle) = 0;
800
801 //-----------------------------------------------------------------------------------------
802 //
803 // SelectConfiguration
804 //
805 // Description: selects a interface of an configuration
806
807 virtual NTSTATUS SelectInterface(IN USBD_CONFIGURATION_HANDLE ConfigurationHandle,
808 IN OUT PUSBD_INTERFACE_INFORMATION Interface) = 0;
809 };
810
811 typedef IUSBDevice *PUSBDEVICE;
812
813 #endif