projects / reactos.git / blob
? search:


a3d1f9bfbc8bed31d3d96b66b1d57e4c64acc66f
[reactos.git] / reactos / lib / drivers / libusb / common_interfaces.h
1
2 #ifndef COMMON_INTERFACES_HPP
3 #define COMMON_INTERFACES_HPP
4
5 typedef struct _USB_ENDPOINT
6 {
7 USB_ENDPOINT_DESCRIPTOR EndPointDescriptor;
8 UCHAR HubAddress;
9 UCHAR HubPort;
10 UCHAR DataToggle;
11 } USB_ENDPOINT, *PUSB_ENDPOINT;
12
13 typedef struct _USB_INTERFACE
14 {
15 LIST_ENTRY ListEntry;
16 PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
17 USB_ENDPOINT EndPoints[1];
18 } USB_INTERFACE, *PUSB_INTERFACE;
19
20 typedef struct
21 {
22 PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor;
23 LIST_ENTRY InterfaceList;
24 }USB_CONFIGURATION, *PUSB_CONFIGURATION;
25
26 //---------------------------------------------------------------------------
27 //
28 // Object Hierachy
29 // --------------------------------------------------------------------
30 // | IRootHCDController |
31 // | IHCDController Intel USB Universal Host Controller - 3A37 |
32 // | IHCDController - Intel USB Universal HostController - 3A38 |
33 // | IHCDController - Intel USB Universal HostController - 3A38 |
34 // |------------------------------------------------------------------|
35 //
36 //
37 // IHCDController Intel USB Universal Host Controller - 3A37
38 // IHubController
39 // IUSBHardwareDevice
40 // IDMAMemoryManager
41 // IUSBQueue <- interacts with -> IUSBRequest
42 //
43 //
44 // Each IHCDController creates an IUSBHardwareDevice class upon initialization. The
45 // IUSBHardwardeDevice class is used to abstract usb controller specifics. The IHubController
46 // manages all attached devices and handles hub control ioctl requests.
47 //
48 // Each IUSBHardwareDevice has one IDMAMemoryManager and one IUSBQueue. The IDMAMemoryManager
49 // is used to handle dma memory allocations. The IUSBQueue manages requests which are send to the
50 // usb hardware. See IUSBRequest class for details.
51 //
52
53
54 //=========================================================================================
55 //
56 // class IRootHCDController
57 //
58 // Description: This class serves as the root host controller. The host controller mantains
59 // a list of registered controllers and provides support functions for the host controllers
60
61 struct IHCDController;
62
63 DECLARE_INTERFACE_(IRootHCDController, IUnknown)
64 {
65 DEFINE_ABSTRACT_UNKNOWN()
66
67 //-----------------------------------------------------------------------------------------
68 //
69 // Initialize
70 //
71 // Description: This function initializes the root host controller. It allocates the resources
72 // required to manage the registered controllers
73
74 virtual NTSTATUS Initialize() = 0;
75
76 //-----------------------------------------------------------------------------------------
77 //
78 // RegisterHCD
79 //
80 // Description: this function registers a host controller with the root host controller
81
82 virtual NTSTATUS RegisterHCD(struct IHCDController * Controller) = 0;
83
84 //-----------------------------------------------------------------------------------------
85 //
86 // UnregisterHCD
87 //
88 // Description: this function unregistes a host controller
89
90 virtual NTSTATUS UnregisterHCD(struct IHCDController * Controller) = 0;
91
92 //-----------------------------------------------------------------------------------------
93 //
94 // GetControllerCount
95 //
96 // Description: returns the number of host controllers registered
97
98 virtual ULONG GetControllerCount() = 0;
99
100 };
101
102 typedef IRootHCDController *PROOTHDCCONTROLLER;
103
104 //=========================================================================================
105 //
106 // class IHCDController
107 //
108 // Description: This class is used to manage a single USB host controller
109 //
110
111 DECLARE_INTERFACE_(IHCDController, IUnknown)
112 {
113 DEFINE_ABSTRACT_UNKNOWN()
114
115 //-----------------------------------------------------------------------------------------
116 //
117 // Initialize
118 //
119 // Description: This function initializes the IHCDController implementation.
120 // It creates an IUSBHardwareDevice object and initializes it. It also registeres itself with
121 // the IRootHCDController
122 //
123 virtual NTSTATUS Initialize(IN PROOTHDCCONTROLLER RootHCDController,
124 IN PDRIVER_OBJECT DriverObject,
125 IN PDEVICE_OBJECT PhysicalDeviceObject) = 0;
126
127 };
128
129 typedef IHCDController *PHCDCONTROLLER;
130
131
132 //=========================================================================================
133 //
134 // class IUSBHardwareDevice
135 //
136 // Description: This class provides access to the usb hardware controller
137 //
138
139 struct IDMAMemoryManager;
140 struct IUSBQueue;
141
142 #define DEFINE_ABSTRACT_USBHARDWAREDEVICE() \
143 STDMETHOD_(NTSTATUS, Initialize)( THIS_ \
144 IN PDRIVER_OBJECT DriverObject, \
145 IN PDEVICE_OBJECT FunctionalDeviceObject, \
146 IN PDEVICE_OBJECT PhysicalDeviceObject, \
147 IN PDEVICE_OBJECT LowerDeviceObject) PURE; \
148 \
149 STDMETHOD_(NTSTATUS, PnpStart)( THIS_ \
150 IN PCM_RESOURCE_LIST RawResources, \
151 IN PCM_RESOURCE_LIST TranslatedResources) PURE; \
152 \
153 STDMETHOD_(NTSTATUS, PnpStop)( THIS) PURE; \
154 \
155 STDMETHOD_(NTSTATUS, GetDeviceDetails)( THIS_ \
156 OUT OPTIONAL PUSHORT VendorId, \
157 OUT OPTIONAL PUSHORT DeviceId, \
158 OUT OPTIONAL PULONG NumberOfPorts, \
159 OUT OPTIONAL PULONG Speed) PURE; \
160 \
161 STDMETHOD_(NTSTATUS, GetUSBQueue)( THIS_ \
162 OUT struct IUSBQueue **OutUsbQueue) PURE; \
163 \
164 STDMETHOD_(NTSTATUS, GetDMA)( THIS_ \
165 OUT struct IDMAMemoryManager **OutDMA) PURE; \
166 \
167 STDMETHOD_(NTSTATUS, ResetPort)( THIS_ \
168 IN ULONG PortNumber) PURE; \
169 \
170 STDMETHOD_(NTSTATUS, GetPortStatus)( THIS_ \
171 IN ULONG PortId, \
172 OUT USHORT *PortStatus, \
173 OUT USHORT *PortChange) PURE; \
174 \
175 STDMETHOD_(NTSTATUS, ClearPortStatus)( THIS_ \
176 IN ULONG PortId, \
177 IN ULONG Status) PURE; \
178 \
179 STDMETHOD_(NTSTATUS, SetPortFeature)( THIS_ \
180 IN ULONG PortId, \
181 IN ULONG Feature) PURE; \
182 \
183 STDMETHOD_(VOID, SetStatusChangeEndpointCallBack)( THIS_ \
184 IN PVOID CallBack, \
185 IN PVOID Context) PURE; \
186 \
187 STDMETHOD_(LPCSTR, GetUSBType)(THIS) PURE;
188
189
190 #define IMP_IUSBHARDWAREDEVICE \
191 STDMETHODIMP_(NTSTATUS) Initialize( \
192 IN PDRIVER_OBJECT DriverObject, \
193 IN PDEVICE_OBJECT FunctionalDeviceObject, \
194 IN PDEVICE_OBJECT PhysicalDeviceObject, \
195 IN PDEVICE_OBJECT LowerDeviceObject); \
196 \
197 STDMETHODIMP_(NTSTATUS) PnpStart( \
198 IN PCM_RESOURCE_LIST RawResources, \
199 IN PCM_RESOURCE_LIST TranslatedResources); \
200 \
201 STDMETHODIMP_(NTSTATUS) PnpStop(VOID); \
202 \
203 STDMETHODIMP_(NTSTATUS) GetDeviceDetails( \
204 OUT OPTIONAL PUSHORT VendorId, \
205 OUT OPTIONAL PUSHORT DeviceId, \
206 OUT OPTIONAL PULONG NumberOfPorts, \
207 OUT OPTIONAL PULONG Speed); \
208 \
209 STDMETHODIMP_(NTSTATUS) GetUSBQueue( \
210 OUT struct IUSBQueue **OutUsbQueue); \
211 \
212 STDMETHODIMP_(NTSTATUS) GetDMA( \
213 OUT struct IDMAMemoryManager **OutDMA); \
214 \
215 STDMETHODIMP_(NTSTATUS) ResetPort( \
216 IN ULONG PortNumber); \
217 \
218 STDMETHODIMP_(NTSTATUS) GetPortStatus( \
219 IN ULONG PortId, \
220 OUT USHORT *PortStatus, \
221 OUT USHORT *PortChange); \
222 \
223 STDMETHODIMP_(NTSTATUS) ClearPortStatus( \
224 IN ULONG PortId, \
225 IN ULONG Status); \
226 \
227 STDMETHODIMP_(NTSTATUS) SetPortFeature( \
228 IN ULONG PortId, \
229 IN ULONG Feature); \
230 \
231 STDMETHODIMP_(VOID) SetStatusChangeEndpointCallBack( \
232 IN PVOID CallBack, \
233 IN PVOID Context); \
234 \
235 STDMETHODIMP_(LPCSTR) GetUSBType();
236
237 DECLARE_INTERFACE_(IUSBHardwareDevice, IUnknown)
238 {
239 DEFINE_ABSTRACT_UNKNOWN()
240 DEFINE_ABSTRACT_USBHARDWAREDEVICE()
241 };
242
243 typedef IUSBHardwareDevice *PUSBHARDWAREDEVICE;
244
245
246 //=========================================================================================
247 //
248 // class IDMAMemoryManager
249 //
250 // Description: This class provides access to the dma buffer. It provides methods to
251 // allocate and free from the dma buffer
252 //
253
254 DECLARE_INTERFACE_(IDMAMemoryManager, IUnknown)
255 {
256 DEFINE_ABSTRACT_UNKNOWN()
257
258 //-----------------------------------------------------------------------------------------
259 //
260 // Initialize
261 //
262 // Description: initializes the memory manager
263
264 virtual NTSTATUS Initialize(IN PUSBHARDWAREDEVICE Device,
265 IN PKSPIN_LOCK Lock,
266 IN ULONG DmaBufferSize,
267 IN PVOID VirtualBase,
268 IN PHYSICAL_ADDRESS PhysicalAddress,
269 IN ULONG DefaultBlockSize) = 0;
270
271 //-----------------------------------------------------------------------------------------
272 //
273 // Allocate
274 //
275 // Description: allocates block of memory from allocator
276
277 virtual NTSTATUS Allocate(IN ULONG Size,
278 OUT PVOID *OutVirtualBase,
279 OUT PPHYSICAL_ADDRESS OutPhysicalAddress) = 0;
280
281
282 //-----------------------------------------------------------------------------------------
283 //
284 // Free
285 //
286 // Description: releases memory block
287
288 virtual NTSTATUS Release(IN PVOID VirtualBase,
289 IN ULONG Size) = 0;
290
291 };
292
293 typedef IDMAMemoryManager *PDMAMEMORYMANAGER;
294
295
296 //=========================================================================================
297 //
298 // class IUSBRequest
299 //
300 // Description: This class is used to issue request to usb controller. The class is
301 // initialized using InitializeXXX methods. You also need to call SetEndpoint to define the endpoint
302 // In addition you can call SetCompletionDetails if you need to wait for the end of
303 // the request or want to complete an irp. You call AddUSBRequest to add the request to the queue.
304 // Once the request is completed the CompletionCallback is invoked. The CompletionCallback
305 // will take care of any completion details which have been set. If the request is cancelled, the
306 // CancelCallback routine is invoked.
307 //
308
309 struct IUSBDevice;
310
311 #define DEFINE_ABSTRACT_USBREQUEST() \
312 STDMETHOD_(NTSTATUS, InitializeWithSetupPacket)( THIS_ \
313 IN PDMAMEMORYMANAGER DmaManager, \
314 IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket, \
315 IN struct IUSBDevice *Device, \
316 IN OPTIONAL struct _USB_ENDPOINT *EndpointDescriptor, \
317 IN OUT ULONG TransferBufferLength, \
318 IN OUT PMDL TransferBuffer) PURE; \
319 \
320 STDMETHOD_(NTSTATUS, InitializeWithIrp)( THIS_ \
321 IN PDMAMEMORYMANAGER DmaManager, \
322 IN struct IUSBDevice *Device, \
323 IN OUT PIRP Irp) PURE; \
324 \
325 STDMETHOD_(BOOLEAN, IsRequestComplete)( THIS) PURE; \
326 \
327 STDMETHOD_(ULONG, GetTransferType)( THIS) PURE; \
328 \
329 STDMETHOD_(VOID, GetResultStatus)( THIS_ \
330 OUT OPTIONAL NTSTATUS * NtStatusCode, \
331 OUT OPTIONAL PULONG UrbStatusCode) PURE;
332
333 #define IMP_IUSBREQUEST \
334 STDMETHODIMP_(NTSTATUS) InitializeWithSetupPacket( \
335 IN PDMAMEMORYMANAGER DmaManager, \
336 IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket, \
337 IN struct IUSBDevice *Device, \
338 IN OPTIONAL struct _USB_ENDPOINT *EndpointDescriptor, \
339 IN OUT ULONG TransferBufferLength, \
340 IN OUT PMDL TransferBuffer); \
341 \
342 STDMETHODIMP_(NTSTATUS) InitializeWithIrp( \
343 IN PDMAMEMORYMANAGER DmaManager, \
344 IN struct IUSBDevice *Device, \
345 IN OUT PIRP Irp); \
346 \
347 STDMETHODIMP_(BOOLEAN) IsRequestComplete(VOID); \
348 \
349 STDMETHODIMP_(ULONG) GetTransferType(VOID); \
350 \
351 STDMETHODIMP_(VOID) GetResultStatus( \
352 OUT OPTIONAL NTSTATUS * NtStatusCode, \
353 OUT OPTIONAL PULONG UrbStatusCode);
354
355 DECLARE_INTERFACE_(IUSBRequest, IUnknown)
356 {
357 DEFINE_ABSTRACT_UNKNOWN()
358 DEFINE_ABSTRACT_USBREQUEST()
359 };
360
361
362 typedef IUSBRequest *PUSBREQUEST;
363
364 //=========================================================================================
365 //
366 // class IUSBQueue
367 //
368 // Description: This class manages pending requests
369 //
370
371 #define DEFINE_ABSTRACT_USBQUEUE() \
372 STDMETHOD_(NTSTATUS, Initialize)( THIS_ \
373 IN PUSBHARDWAREDEVICE Hardware, \
374 IN PDMA_ADAPTER AdapterObject, \
375 IN PDMAMEMORYMANAGER MemManager, \
376 IN OPTIONAL PKSPIN_LOCK Lock) PURE; \
377 \
378 STDMETHOD_(NTSTATUS, AddUSBRequest)( THIS_ \
379 IN IUSBRequest * Request) PURE; \
380 \
381 STDMETHOD_(NTSTATUS, CreateUSBRequest)( THIS_ \
382 IN IUSBRequest **OutRequest) PURE; \
383 \
384 STDMETHOD_(NTSTATUS, AbortDevicePipe)( THIS_ \
385 IN UCHAR DeviceAddress, \
386 IN PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor) PURE;
387
388 #define IMP_IUSBQUEUE \
389 STDMETHODIMP_(NTSTATUS) Initialize( \
390 IN PUSBHARDWAREDEVICE Hardware, \
391 IN PDMA_ADAPTER AdapterObject, \
392 IN PDMAMEMORYMANAGER MemManager, \
393 IN OPTIONAL PKSPIN_LOCK Lock); \
394 \
395 STDMETHODIMP_(NTSTATUS) AddUSBRequest( \
396 IN IUSBRequest * Request); \
397 \
398 STDMETHODIMP_(NTSTATUS) CreateUSBRequest( \
399 OUT IUSBRequest **OutRequest); \
400 \
401 STDMETHODIMP_(NTSTATUS) AbortDevicePipe( \
402 IN UCHAR DeviceAddress, \
403 IN PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor);
404
405 DECLARE_INTERFACE_(IUSBQueue, IUnknown)
406 {
407 DEFINE_ABSTRACT_UNKNOWN()
408 DEFINE_ABSTRACT_USBQUEUE()
409 };
410
411 typedef IUSBQueue *PUSBQUEUE;
412
413 //=========================================================================================
414 //
415 // class IHubController
416 //
417 // Description: This class implements a hub controller
418 //
419
420 DECLARE_INTERFACE_(IHubController, IUnknown)
421 {
422 DEFINE_ABSTRACT_UNKNOWN()
423
424 //----------------------------------------------------------------------------------------
425 //
426 // Initialize
427 //
428 // Description: Initializes the hub controller
429
430 virtual NTSTATUS Initialize(IN PDRIVER_OBJECT DriverObject,
431 IN PHCDCONTROLLER Controller,
432 IN PUSBHARDWAREDEVICE Device,
433 IN BOOLEAN IsRootHubDevice,
434 IN ULONG DeviceAddress) = 0;
435
436 //----------------------------------------------------------------------------------------
437 //
438 // GetHubControllerDeviceObject
439 //
440 // Description: Returns the hub controller device object
441
442 virtual NTSTATUS GetHubControllerDeviceObject(PDEVICE_OBJECT * HubDeviceObject) = 0;
443
444 //----------------------------------------------------------------------------------------
445 //
446 // GetHubControllerSymbolicLink
447 //
448 // Description: Returns the symbolic link of the root hub
449
450 virtual NTSTATUS GetHubControllerSymbolicLink(ULONG BufferLength, PVOID Buffer, PULONG RequiredLength) = 0;
451
452
453 };
454
455 typedef IHubController *PHUBCONTROLLER;
456
457 //=========================================================================================
458 //
459 // class IDispatchIrp
460 //
461 // Description: This class is used to handle irp dispatch requests
462 //
463
464 DECLARE_INTERFACE_(IDispatchIrp, IUnknown)
465 {
466 DEFINE_ABSTRACT_UNKNOWN()
467
468 //-----------------------------------------------------------------------------------------
469 //
470 // HandlePnp
471 //
472 // Description: This function handles all pnp requests
473
474 virtual NTSTATUS HandlePnp(IN PDEVICE_OBJECT DeviceObject,
475 IN OUT PIRP Irp) = 0;
476
477 //-----------------------------------------------------------------------------------------
478 //
479 // HandlePower
480 //
481 // Description: This function handles all power pnp requests
482 //
483 virtual NTSTATUS HandlePower(IN PDEVICE_OBJECT DeviceObject,
484 IN OUT PIRP Irp) = 0;
485
486 //-----------------------------------------------------------------------------------------
487 //
488 // HandleDeviceControl
489 //
490 // Description: handles device io control requests
491
492 virtual NTSTATUS HandleDeviceControl(IN PDEVICE_OBJECT DeviceObject,
493 IN OUT PIRP Irp) = 0;
494
495 //-----------------------------------------------------------------------------------------
496 //
497 // HandleSystemControl
498 //
499 // Description: handles WMI system control requests
500
501 virtual NTSTATUS HandleSystemControl(IN PDEVICE_OBJECT DeviceObject,
502 IN OUT PIRP Irp) = 0;
503 };
504
505 typedef IDispatchIrp *PDISPATCHIRP;
506
507 //=========================================================================================
508 //
509 // class IUSBDevice
510 //
511 // Description: This class is used to abstract details of a usb device
512 //
513
514 DECLARE_INTERFACE_(IUSBDevice, IUnknown)
515 {
516 DEFINE_ABSTRACT_UNKNOWN()
517
518 //----------------------------------------------------------------------------------------
519 //
520 // Initialize
521 //
522 // Description: Initializes the usb device
523
524 virtual NTSTATUS Initialize(IN PHUBCONTROLLER HubController,
525 IN PUSBHARDWAREDEVICE Device,
526 IN PVOID Parent,
527 IN ULONG Port,
528 IN ULONG PortStatus) = 0;
529
530 //-----------------------------------------------------------------------------------------
531 //
532 // IsHub
533 //
534 // Description: returns true when device is a hub
535
536 virtual BOOLEAN IsHub() = 0;
537
538 //-----------------------------------------------------------------------------------------
539 //
540 // GetParent
541 //
542 // Description: gets the parent device of the this device
543
544 virtual NTSTATUS GetParent(PVOID * Parent) = 0;
545
546 //-----------------------------------------------------------------------------------------
547 //
548 // GetDeviceAddress
549 //
550 // Description: gets the device address of the this device
551
552 virtual UCHAR GetDeviceAddress() = 0;
553
554
555 //-----------------------------------------------------------------------------------------
556 //
557 // GetPort
558 //
559 // Description: gets the port to which this device is connected
560
561 virtual ULONG GetPort() = 0;
562
563 //-----------------------------------------------------------------------------------------
564 //
565 // GetSpeed
566 //
567 // Description: gets the speed of the device
568
569 virtual USB_DEVICE_SPEED GetSpeed() = 0;
570
571 //-----------------------------------------------------------------------------------------
572 //
573 // GetType
574 //
575 // Description: gets the type of the device, either 1.1 or 2.0 device
576
577 virtual USB_DEVICE_TYPE GetType() = 0;
578
579 //-----------------------------------------------------------------------------------------
580 //
581 // GetState
582 //
583 // Description: gets the device state
584
585 virtual ULONG GetState() = 0;
586
587 //-----------------------------------------------------------------------------------------
588 //
589 // SetDeviceHandleData
590 //
591 // Description: sets device handle data
592
593 virtual void SetDeviceHandleData(PVOID Data) = 0;
594
595 //-----------------------------------------------------------------------------------------
596 //
597 // SetDeviceAddress
598 //
599 // Description: sets device handle data
600
601 virtual NTSTATUS SetDeviceAddress(UCHAR DeviceAddress) = 0;
602
603 //-----------------------------------------------------------------------------------------
604 //
605 // GetDeviceDescriptor
606 //
607 // Description: sets device handle data
608
609 virtual void GetDeviceDescriptor(PUSB_DEVICE_DESCRIPTOR DeviceDescriptor) = 0;
610
611 //-----------------------------------------------------------------------------------------
612 //
613 // GetConfigurationValue
614 //
615 // Description: gets current selected configuration index
616
617 virtual UCHAR GetConfigurationValue() = 0;
618
619 //-----------------------------------------------------------------------------------------
620 //
621 // SubmitIrp
622 //
623 // Description: submits an irp containing an urb
624
625 virtual NTSTATUS SubmitIrp(PIRP Irp) = 0;
626
627 //-----------------------------------------------------------------------------------------
628 //
629 // GetConfigurationDescriptors
630 //
631 // Description: returns one or more configuration descriptors
632
633 virtual VOID GetConfigurationDescriptors(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptorBuffer,
634 IN ULONG BufferLength,
635 OUT PULONG OutBufferLength) = 0;
636
637 //-----------------------------------------------------------------------------------------
638 //
639 // Description: returns length of configuration descriptors
640 //
641 virtual ULONG GetConfigurationDescriptorsLength() = 0;
642
643 //-----------------------------------------------------------------------------------------
644 //
645 // SubmitSetupPacket
646 //
647 // Description: submits an setup packet. The usb device will then create an usb request from it and submit it to the queue
648
649 virtual NTSTATUS SubmitSetupPacket(IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
650 IN OUT ULONG BufferLength,
651 OUT PVOID Buffer) = 0;
652
653 //-----------------------------------------------------------------------------------------
654 //
655 // SelectConfiguration
656 //
657 // Description: selects a configuration
658
659 virtual NTSTATUS SelectConfiguration(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
660 IN PUSBD_INTERFACE_INFORMATION Interface,
661 OUT USBD_CONFIGURATION_HANDLE *ConfigurationHandle) = 0;
662
663 //-----------------------------------------------------------------------------------------
664 //
665 // SelectConfiguration
666 //
667 // Description: selects a interface of an configuration
668
669 virtual NTSTATUS SelectInterface(IN USBD_CONFIGURATION_HANDLE ConfigurationHandle,
670 IN OUT PUSBD_INTERFACE_INFORMATION Interface) = 0;
671
672 //-----------------------------------------------------------------------------------------
673 //
674 // AbortPipe
675 //
676 // Description: aborts all pending requsts
677
678 virtual NTSTATUS AbortPipe(IN PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor) = 0;
679
680 //-----------------------------------------------------------------------------------------
681 //
682 // GetMaxPacketSize
683 //
684 // Description: aborts all pending requsts
685
686 virtual UCHAR GetMaxPacketSize() = 0;
687 };
688
689 typedef IUSBDevice *PUSBDEVICE;
690
691 #endif
A free Windows-compatible Operating System