MdeModulePkg/XhciDxe: Check timeout URB again after stopping endpoint
[mirror_edk2.git] / MdeModulePkg / Bus / Pci / XhciDxe / Xhci.h
1 /** @file
2
3 Provides some data structure definitions used by the XHCI host controller driver.
4
5 Copyright (c) 2011 - 2017, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #ifndef _EFI_XHCI_H_
17 #define _EFI_XHCI_H_
18
19 #include <Uefi.h>
20
21 #include <Protocol/Usb2HostController.h>
22 #include <Protocol/PciIo.h>
23
24 #include <Guid/EventGroup.h>
25
26 #include <Library/BaseLib.h>
27 #include <Library/BaseMemoryLib.h>
28 #include <Library/UefiDriverEntryPoint.h>
29 #include <Library/UefiBootServicesTableLib.h>
30 #include <Library/MemoryAllocationLib.h>
31 #include <Library/UefiLib.h>
32 #include <Library/DebugLib.h>
33 #include <Library/ReportStatusCodeLib.h>
34
35 #include <IndustryStandard/Pci.h>
36
37 typedef struct _USB_XHCI_INSTANCE USB_XHCI_INSTANCE;
38 typedef struct _USB_DEV_CONTEXT USB_DEV_CONTEXT;
39
40 #include "XhciReg.h"
41 #include "XhciSched.h"
42 #include "ComponentName.h"
43 #include "UsbHcMem.h"
44
45 //
46 // The unit is microsecond, setting it as 1us.
47 //
48 #define XHC_1_MICROSECOND (1)
49 //
50 // The unit is microsecond, setting it as 1ms.
51 //
52 #define XHC_1_MILLISECOND (1000)
53 //
54 // XHC generic timeout experience values.
55 // The unit is millisecond, setting it as 10s.
56 //
57 #define XHC_GENERIC_TIMEOUT (10 * 1000)
58 //
59 // XHC reset timeout experience values.
60 // The unit is millisecond, setting it as 1s.
61 //
62 #define XHC_RESET_TIMEOUT (1000)
63 //
64 // TRSTRCY delay requirement in usb 2.0 spec chapter 7.1.7.5.
65 // The unit is microsecond, setting it as 10ms.
66 //
67 #define XHC_RESET_RECOVERY_DELAY (10 * 1000)
68 //
69 // XHC async transfer timer interval, set by experience.
70 // The unit is 100us, takes 1ms as interval.
71 //
72 #define XHC_ASYNC_TIMER_INTERVAL EFI_TIMER_PERIOD_MILLISECONDS(1)
73
74 //
75 // XHC raises TPL to TPL_NOTIFY to serialize all its operations
76 // to protect shared data structures.
77 //
78 #define XHC_TPL TPL_NOTIFY
79
80 #define CMD_RING_TRB_NUMBER 0x100
81 #define TR_RING_TRB_NUMBER 0x100
82 #define ERST_NUMBER 0x01
83 #define EVENT_RING_TRB_NUMBER 0x200
84
85 #define CMD_INTER 0
86 #define CTRL_INTER 1
87 #define BULK_INTER 2
88 #define INT_INTER 3
89 #define INT_INTER_ASYNC 4
90
91 //
92 // Iterate through the double linked list. This is delete-safe.
93 // Don't touch NextEntry
94 //
95 #define EFI_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \
96 for (Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink;\
97 Entry != (ListHead); Entry = NextEntry, NextEntry = Entry->ForwardLink)
98
99 #define EFI_LIST_CONTAINER(Entry, Type, Field) BASE_CR(Entry, Type, Field)
100
101 #define XHC_LOW_32BIT(Addr64) ((UINT32)(((UINTN)(Addr64)) & 0xFFFFFFFF))
102 #define XHC_HIGH_32BIT(Addr64) ((UINT32)(RShiftU64((UINT64)(UINTN)(Addr64), 32) & 0xFFFFFFFF))
103 #define XHC_BIT_IS_SET(Data, Bit) ((BOOLEAN)(((Data) & (Bit)) == (Bit)))
104
105 #define XHC_REG_BIT_IS_SET(Xhc, Offset, Bit) \
106 (XHC_BIT_IS_SET(XhcReadOpReg ((Xhc), (Offset)), (Bit)))
107
108 #define XHCI_IS_DATAIN(EndpointAddr) XHC_BIT_IS_SET((EndpointAddr), 0x80)
109
110 #define XHCI_INSTANCE_SIG SIGNATURE_32 ('x', 'h', 'c', 'i')
111 #define XHC_FROM_THIS(a) CR(a, USB_XHCI_INSTANCE, Usb2Hc, XHCI_INSTANCE_SIG)
112
113 #define USB_DESC_TYPE_HUB 0x29
114 #define USB_DESC_TYPE_HUB_SUPER_SPEED 0x2a
115
116 //
117 // The RequestType in EFI_USB_DEVICE_REQUEST is composed of
118 // three fields: One bit direction, 2 bit type, and 5 bit
119 // target.
120 //
121 #define USB_REQUEST_TYPE(Dir, Type, Target) \
122 ((UINT8)((((Dir) == EfiUsbDataIn ? 0x01 : 0) << 7) | (Type) | (Target)))
123
124 //
125 // Xhci Data and Ctrl Structures
126 //
127 #pragma pack(1)
128 typedef struct {
129 UINT8 ProgInterface;
130 UINT8 SubClassCode;
131 UINT8 BaseCode;
132 } USB_CLASSC;
133
134 typedef struct {
135 UINT8 Length;
136 UINT8 DescType;
137 UINT8 NumPorts;
138 UINT16 HubCharacter;
139 UINT8 PwrOn2PwrGood;
140 UINT8 HubContrCurrent;
141 UINT8 Filler[16];
142 } EFI_USB_HUB_DESCRIPTOR;
143 #pragma pack()
144
145 struct _USB_DEV_CONTEXT {
146 //
147 // Whether this entry in UsbDevContext array is used or not.
148 //
149 BOOLEAN Enabled;
150 //
151 // The slot id assigned to the new device through XHCI's Enable_Slot cmd.
152 //
153 UINT8 SlotId;
154 //
155 // The route string presented an attached usb device.
156 //
157 USB_DEV_ROUTE RouteString;
158 //
159 // The route string of parent device if it exists. Otherwise it's zero.
160 //
161 USB_DEV_ROUTE ParentRouteString;
162 //
163 // The actual device address assigned by XHCI through Address_Device command.
164 //
165 UINT8 XhciDevAddr;
166 //
167 // The requested device address from UsbBus driver through Set_Address standard usb request.
168 // As XHCI spec replaces this request with Address_Device command, we have to record the
169 // requested device address and establish a mapping relationship with the actual device address.
170 // Then UsbBus driver just need to be aware of the requested device address to access usb device
171 // through EFI_USB2_HC_PROTOCOL. Xhci driver would be responsible for translating it to actual
172 // device address and access the actual device.
173 //
174 UINT8 BusDevAddr;
175 //
176 // The pointer to the input device context.
177 //
178 VOID *InputContext;
179 //
180 // The pointer to the output device context.
181 //
182 VOID *OutputContext;
183 //
184 // The transfer queue for every endpoint.
185 //
186 VOID *EndpointTransferRing[31];
187 //
188 // The device descriptor which is stored to support XHCI's Evaluate_Context cmd.
189 //
190 EFI_USB_DEVICE_DESCRIPTOR DevDesc;
191 //
192 // As a usb device may include multiple configuration descriptors, we dynamically allocate an array
193 // to store them.
194 // Note that every configuration descriptor stored here includes those lower level descriptors,
195 // such as Interface descriptor, Endpoint descriptor, and so on.
196 // These information is used to support XHCI's Config_Endpoint cmd.
197 //
198 EFI_USB_CONFIG_DESCRIPTOR **ConfDesc;
199 //
200 // A device has an active Configuration.
201 //
202 UINT8 ActiveConfiguration;
203 //
204 // Every interface has an active AlternateSetting.
205 //
206 UINT8 *ActiveAlternateSetting;
207 };
208
209 struct _USB_XHCI_INSTANCE {
210 UINT32 Signature;
211 EFI_PCI_IO_PROTOCOL *PciIo;
212 UINT64 OriginalPciAttributes;
213 USBHC_MEM_POOL *MemPool;
214
215 EFI_USB2_HC_PROTOCOL Usb2Hc;
216
217 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
218
219 //
220 // ExitBootServicesEvent is used to set OS semaphore and
221 // stop the XHC DMA operation after exit boot service.
222 //
223 EFI_EVENT ExitBootServiceEvent;
224 EFI_EVENT PollTimer;
225 LIST_ENTRY AsyncIntTransfers;
226
227 UINT8 CapLength; ///< Capability Register Length
228 XHC_HCSPARAMS1 HcSParams1; ///< Structural Parameters 1
229 XHC_HCSPARAMS2 HcSParams2; ///< Structural Parameters 2
230 XHC_HCCPARAMS HcCParams; ///< Capability Parameters
231 UINT32 DBOff; ///< Doorbell Offset
232 UINT32 RTSOff; ///< Runtime Register Space Offset
233 UINT16 MaxInterrupt;
234 UINT32 PageSize;
235 UINT64 *ScratchBuf;
236 VOID *ScratchMap;
237 UINT32 MaxScratchpadBufs;
238 UINT64 *ScratchEntry;
239 UINTN *ScratchEntryMap;
240 UINT32 ExtCapRegBase;
241 UINT32 UsbLegSupOffset;
242 UINT32 DebugCapSupOffset;
243 UINT64 *DCBAA;
244 VOID *DCBAAMap;
245 UINT32 MaxSlotsEn;
246 URB *PendingUrb;
247 //
248 // Cmd Transfer Ring
249 //
250 TRANSFER_RING CmdRing;
251 //
252 // EventRing
253 //
254 EVENT_RING EventRing;
255 //
256 // Misc
257 //
258 EFI_UNICODE_STRING_TABLE *ControllerNameTable;
259
260 //
261 // Store device contexts managed by XHCI instance
262 // The array supports up to 255 devices, entry 0 is reserved and should not be used.
263 //
264 USB_DEV_CONTEXT UsbDevContext[256];
265
266 BOOLEAN Support64BitDma; // Whether 64 bit DMA may be used with this device
267 };
268
269
270 extern EFI_DRIVER_BINDING_PROTOCOL gXhciDriverBinding;
271 extern EFI_COMPONENT_NAME_PROTOCOL gXhciComponentName;
272 extern EFI_COMPONENT_NAME2_PROTOCOL gXhciComponentName2;
273
274 /**
275 Test to see if this driver supports ControllerHandle. Any
276 ControllerHandle that has Usb2HcProtocol installed will
277 be supported.
278
279 @param This Protocol instance pointer.
280 @param Controller Handle of device to test.
281 @param RemainingDevicePath Not used.
282
283 @return EFI_SUCCESS This driver supports this device.
284 @return EFI_UNSUPPORTED This driver does not support this device.
285
286 **/
287 EFI_STATUS
288 EFIAPI
289 XhcDriverBindingSupported (
290 IN EFI_DRIVER_BINDING_PROTOCOL *This,
291 IN EFI_HANDLE Controller,
292 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
293 );
294
295 /**
296 Starting the Usb XHCI Driver.
297
298 @param This Protocol instance pointer.
299 @param Controller Handle of device to test.
300 @param RemainingDevicePath Not used.
301
302 @return EFI_SUCCESS supports this device.
303 @return EFI_UNSUPPORTED do not support this device.
304 @return EFI_DEVICE_ERROR cannot be started due to device Error.
305 @return EFI_OUT_OF_RESOURCES cannot allocate resources.
306
307 **/
308 EFI_STATUS
309 EFIAPI
310 XhcDriverBindingStart (
311 IN EFI_DRIVER_BINDING_PROTOCOL *This,
312 IN EFI_HANDLE Controller,
313 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
314 );
315
316 /**
317 Stop this driver on ControllerHandle. Support stopping any child handles
318 created by this driver.
319
320 @param This Protocol instance pointer.
321 @param Controller Handle of device to stop driver on.
322 @param NumberOfChildren Number of Children in the ChildHandleBuffer.
323 @param ChildHandleBuffer List of handles for the children we need to stop.
324
325 @return EFI_SUCCESS Success.
326 @return EFI_DEVICE_ERROR Fail.
327
328 **/
329 EFI_STATUS
330 EFIAPI
331 XhcDriverBindingStop (
332 IN EFI_DRIVER_BINDING_PROTOCOL *This,
333 IN EFI_HANDLE Controller,
334 IN UINTN NumberOfChildren,
335 IN EFI_HANDLE *ChildHandleBuffer
336 );
337
338 /**
339 Retrieves the capability of root hub ports.
340
341 @param This The EFI_USB2_HC_PROTOCOL instance.
342 @param MaxSpeed Max speed supported by the controller.
343 @param PortNumber Number of the root hub ports.
344 @param Is64BitCapable Whether the controller supports 64-bit memory
345 addressing.
346
347 @retval EFI_SUCCESS Host controller capability were retrieved successfully.
348 @retval EFI_INVALID_PARAMETER Either of the three capability pointer is NULL.
349
350 **/
351 EFI_STATUS
352 EFIAPI
353 XhcGetCapability (
354 IN EFI_USB2_HC_PROTOCOL *This,
355 OUT UINT8 *MaxSpeed,
356 OUT UINT8 *PortNumber,
357 OUT UINT8 *Is64BitCapable
358 );
359
360 /**
361 Provides software reset for the USB host controller.
362
363 @param This This EFI_USB2_HC_PROTOCOL instance.
364 @param Attributes A bit mask of the reset operation to perform.
365
366 @retval EFI_SUCCESS The reset operation succeeded.
367 @retval EFI_INVALID_PARAMETER Attributes is not valid.
368 @retval EFI_UNSUPPOURTED The type of reset specified by Attributes is
369 not currently supported by the host controller.
370 @retval EFI_DEVICE_ERROR Host controller isn't halted to reset.
371
372 **/
373 EFI_STATUS
374 EFIAPI
375 XhcReset (
376 IN EFI_USB2_HC_PROTOCOL *This,
377 IN UINT16 Attributes
378 );
379
380 /**
381 Retrieve the current state of the USB host controller.
382
383 @param This This EFI_USB2_HC_PROTOCOL instance.
384 @param State Variable to return the current host controller
385 state.
386
387 @retval EFI_SUCCESS Host controller state was returned in State.
388 @retval EFI_INVALID_PARAMETER State is NULL.
389 @retval EFI_DEVICE_ERROR An error was encountered while attempting to
390 retrieve the host controller's current state.
391
392 **/
393 EFI_STATUS
394 EFIAPI
395 XhcGetState (
396 IN EFI_USB2_HC_PROTOCOL *This,
397 OUT EFI_USB_HC_STATE *State
398 );
399
400 /**
401 Sets the USB host controller to a specific state.
402
403 @param This This EFI_USB2_HC_PROTOCOL instance.
404 @param State The state of the host controller that will be set.
405
406 @retval EFI_SUCCESS The USB host controller was successfully placed
407 in the state specified by State.
408 @retval EFI_INVALID_PARAMETER State is invalid.
409 @retval EFI_DEVICE_ERROR Failed to set the state due to device error.
410
411 **/
412 EFI_STATUS
413 EFIAPI
414 XhcSetState (
415 IN EFI_USB2_HC_PROTOCOL *This,
416 IN EFI_USB_HC_STATE State
417 );
418
419 /**
420 Retrieves the current status of a USB root hub port.
421
422 @param This This EFI_USB2_HC_PROTOCOL instance.
423 @param PortNumber The root hub port to retrieve the state from.
424 This value is zero-based.
425 @param PortStatus Variable to receive the port state.
426
427 @retval EFI_SUCCESS The status of the USB root hub port specified.
428 by PortNumber was returned in PortStatus.
429 @retval EFI_INVALID_PARAMETER PortNumber is invalid.
430 @retval EFI_DEVICE_ERROR Can't read register.
431
432 **/
433 EFI_STATUS
434 EFIAPI
435 XhcGetRootHubPortStatus (
436 IN EFI_USB2_HC_PROTOCOL *This,
437 IN UINT8 PortNumber,
438 OUT EFI_USB_PORT_STATUS *PortStatus
439 );
440
441 /**
442 Sets a feature for the specified root hub port.
443
444 @param This This EFI_USB2_HC_PROTOCOL instance.
445 @param PortNumber Root hub port to set.
446 @param PortFeature Feature to set.
447
448 @retval EFI_SUCCESS The feature specified by PortFeature was set.
449 @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.
450 @retval EFI_DEVICE_ERROR Can't read register.
451
452 **/
453 EFI_STATUS
454 EFIAPI
455 XhcSetRootHubPortFeature (
456 IN EFI_USB2_HC_PROTOCOL *This,
457 IN UINT8 PortNumber,
458 IN EFI_USB_PORT_FEATURE PortFeature
459 );
460
461 /**
462 Clears a feature for the specified root hub port.
463
464 @param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
465 @param PortNumber Specifies the root hub port whose feature is
466 requested to be cleared.
467 @param PortFeature Indicates the feature selector associated with the
468 feature clear request.
469
470 @retval EFI_SUCCESS The feature specified by PortFeature was cleared
471 for the USB root hub port specified by PortNumber.
472 @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.
473 @retval EFI_DEVICE_ERROR Can't read register.
474
475 **/
476 EFI_STATUS
477 EFIAPI
478 XhcClearRootHubPortFeature (
479 IN EFI_USB2_HC_PROTOCOL *This,
480 IN UINT8 PortNumber,
481 IN EFI_USB_PORT_FEATURE PortFeature
482 );
483
484 /**
485 Submits control transfer to a target USB device.
486
487 @param This This EFI_USB2_HC_PROTOCOL instance.
488 @param DeviceAddress The target device address.
489 @param DeviceSpeed Target device speed.
490 @param MaximumPacketLength Maximum packet size the default control transfer
491 endpoint is capable of sending or receiving.
492 @param Request USB device request to send.
493 @param TransferDirection Specifies the data direction for the data stage
494 @param Data Data buffer to be transmitted or received from USB
495 device.
496 @param DataLength The size (in bytes) of the data buffer.
497 @param Timeout Indicates the maximum timeout, in millisecond.
498 @param Translator Transaction translator to be used by this device.
499 @param TransferResult Return the result of this control transfer.
500
501 @retval EFI_SUCCESS Transfer was completed successfully.
502 @retval EFI_OUT_OF_RESOURCES The transfer failed due to lack of resources.
503 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
504 @retval EFI_TIMEOUT Transfer failed due to timeout.
505 @retval EFI_DEVICE_ERROR Transfer failed due to host controller or device error.
506
507 **/
508 EFI_STATUS
509 EFIAPI
510 XhcControlTransfer (
511 IN EFI_USB2_HC_PROTOCOL *This,
512 IN UINT8 DeviceAddress,
513 IN UINT8 DeviceSpeed,
514 IN UINTN MaximumPacketLength,
515 IN EFI_USB_DEVICE_REQUEST *Request,
516 IN EFI_USB_DATA_DIRECTION TransferDirection,
517 IN OUT VOID *Data,
518 IN OUT UINTN *DataLength,
519 IN UINTN Timeout,
520 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
521 OUT UINT32 *TransferResult
522 );
523
524 /**
525 Submits bulk transfer to a bulk endpoint of a USB device.
526
527 @param This This EFI_USB2_HC_PROTOCOL instance.
528 @param DeviceAddress Target device address.
529 @param EndPointAddress Endpoint number and its direction in bit 7.
530 @param DeviceSpeed Device speed, Low speed device doesn't support bulk
531 transfer.
532 @param MaximumPacketLength Maximum packet size the endpoint is capable of
533 sending or receiving.
534 @param DataBuffersNumber Number of data buffers prepared for the transfer.
535 @param Data Array of pointers to the buffers of data to transmit
536 from or receive into.
537 @param DataLength The lenght of the data buffer.
538 @param DataToggle On input, the initial data toggle for the transfer;
539 On output, it is updated to to next data toggle to
540 use of the subsequent bulk transfer.
541 @param Timeout Indicates the maximum time, in millisecond, which
542 the transfer is allowed to complete.
543 @param Translator A pointr to the transaction translator data.
544 @param TransferResult A pointer to the detailed result information of the
545 bulk transfer.
546
547 @retval EFI_SUCCESS The transfer was completed successfully.
548 @retval EFI_OUT_OF_RESOURCES The transfer failed due to lack of resource.
549 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
550 @retval EFI_TIMEOUT The transfer failed due to timeout.
551 @retval EFI_DEVICE_ERROR The transfer failed due to host controller error.
552
553 **/
554 EFI_STATUS
555 EFIAPI
556 XhcBulkTransfer (
557 IN EFI_USB2_HC_PROTOCOL *This,
558 IN UINT8 DeviceAddress,
559 IN UINT8 EndPointAddress,
560 IN UINT8 DeviceSpeed,
561 IN UINTN MaximumPacketLength,
562 IN UINT8 DataBuffersNumber,
563 IN OUT VOID *Data[EFI_USB_MAX_BULK_BUFFER_NUM],
564 IN OUT UINTN *DataLength,
565 IN OUT UINT8 *DataToggle,
566 IN UINTN Timeout,
567 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
568 OUT UINT32 *TransferResult
569 );
570
571 /**
572 Submits an asynchronous interrupt transfer to an
573 interrupt endpoint of a USB device.
574
575 @param This This EFI_USB2_HC_PROTOCOL instance.
576 @param DeviceAddress Target device address.
577 @param EndPointAddress Endpoint number and its direction encoded in bit 7
578 @param DeviceSpeed Indicates device speed.
579 @param MaximumPacketLength Maximum packet size the target endpoint is capable
580 @param IsNewTransfer If TRUE, to submit an new asynchronous interrupt
581 transfer If FALSE, to remove the specified
582 asynchronous interrupt.
583 @param DataToggle On input, the initial data toggle to use; on output,
584 it is updated to indicate the next data toggle.
585 @param PollingInterval The he interval, in milliseconds, that the transfer
586 is polled.
587 @param DataLength The length of data to receive at the rate specified
588 by PollingInterval.
589 @param Translator Transaction translator to use.
590 @param CallBackFunction Function to call at the rate specified by
591 PollingInterval.
592 @param Context Context to CallBackFunction.
593
594 @retval EFI_SUCCESS The request has been successfully submitted or canceled.
595 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
596 @retval EFI_OUT_OF_RESOURCES The request failed due to a lack of resources.
597 @retval EFI_DEVICE_ERROR The transfer failed due to host controller error.
598
599 **/
600 EFI_STATUS
601 EFIAPI
602 XhcAsyncInterruptTransfer (
603 IN EFI_USB2_HC_PROTOCOL *This,
604 IN UINT8 DeviceAddress,
605 IN UINT8 EndPointAddress,
606 IN UINT8 DeviceSpeed,
607 IN UINTN MaximumPacketLength,
608 IN BOOLEAN IsNewTransfer,
609 IN OUT UINT8 *DataToggle,
610 IN UINTN PollingInterval,
611 IN UINTN DataLength,
612 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
613 IN EFI_ASYNC_USB_TRANSFER_CALLBACK CallBackFunction,
614 IN VOID *Context OPTIONAL
615 );
616
617 /**
618 Submits synchronous interrupt transfer to an interrupt endpoint
619 of a USB device.
620
621 @param This This EFI_USB2_HC_PROTOCOL instance.
622 @param DeviceAddress Target device address.
623 @param EndPointAddress Endpoint number and its direction encoded in bit 7
624 @param DeviceSpeed Indicates device speed.
625 @param MaximumPacketLength Maximum packet size the target endpoint is capable
626 of sending or receiving.
627 @param Data Buffer of data that will be transmitted to USB
628 device or received from USB device.
629 @param DataLength On input, the size, in bytes, of the data buffer; On
630 output, the number of bytes transferred.
631 @param DataToggle On input, the initial data toggle to use; on output,
632 it is updated to indicate the next data toggle.
633 @param Timeout Maximum time, in second, to complete.
634 @param Translator Transaction translator to use.
635 @param TransferResult Variable to receive the transfer result.
636
637 @return EFI_SUCCESS The transfer was completed successfully.
638 @return EFI_OUT_OF_RESOURCES The transfer failed due to lack of resource.
639 @return EFI_INVALID_PARAMETER Some parameters are invalid.
640 @return EFI_TIMEOUT The transfer failed due to timeout.
641 @return EFI_DEVICE_ERROR The failed due to host controller or device error
642
643 **/
644 EFI_STATUS
645 EFIAPI
646 XhcSyncInterruptTransfer (
647 IN EFI_USB2_HC_PROTOCOL *This,
648 IN UINT8 DeviceAddress,
649 IN UINT8 EndPointAddress,
650 IN UINT8 DeviceSpeed,
651 IN UINTN MaximumPacketLength,
652 IN OUT VOID *Data,
653 IN OUT UINTN *DataLength,
654 IN OUT UINT8 *DataToggle,
655 IN UINTN Timeout,
656 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
657 OUT UINT32 *TransferResult
658 );
659
660 /**
661 Submits isochronous transfer to a target USB device.
662
663 @param This This EFI_USB2_HC_PROTOCOL instance.
664 @param DeviceAddress Target device address.
665 @param EndPointAddress End point address with its direction.
666 @param DeviceSpeed Device speed, Low speed device doesn't support this
667 type.
668 @param MaximumPacketLength Maximum packet size that the endpoint is capable of
669 sending or receiving.
670 @param DataBuffersNumber Number of data buffers prepared for the transfer.
671 @param Data Array of pointers to the buffers of data that will
672 be transmitted to USB device or received from USB
673 device.
674 @param DataLength The size, in bytes, of the data buffer.
675 @param Translator Transaction translator to use.
676 @param TransferResult Variable to receive the transfer result.
677
678 @return EFI_UNSUPPORTED Isochronous transfer is unsupported.
679
680 **/
681 EFI_STATUS
682 EFIAPI
683 XhcIsochronousTransfer (
684 IN EFI_USB2_HC_PROTOCOL *This,
685 IN UINT8 DeviceAddress,
686 IN UINT8 EndPointAddress,
687 IN UINT8 DeviceSpeed,
688 IN UINTN MaximumPacketLength,
689 IN UINT8 DataBuffersNumber,
690 IN OUT VOID *Data[EFI_USB_MAX_ISO_BUFFER_NUM],
691 IN UINTN DataLength,
692 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
693 OUT UINT32 *TransferResult
694 );
695
696 /**
697 Submits Async isochronous transfer to a target USB device.
698
699 @param This This EFI_USB2_HC_PROTOCOL instance.
700 @param DeviceAddress Target device address.
701 @param EndPointAddress End point address with its direction.
702 @param DeviceSpeed Device speed, Low speed device doesn't support this
703 type.
704 @param MaximumPacketLength Maximum packet size that the endpoint is capable of
705 sending or receiving.
706 @param DataBuffersNumber Number of data buffers prepared for the transfer.
707 @param Data Array of pointers to the buffers of data that will
708 be transmitted to USB device or received from USB
709 device.
710 @param DataLength The size, in bytes, of the data buffer.
711 @param Translator Transaction translator to use.
712 @param IsochronousCallBack Function to be called when the transfer complete.
713 @param Context Context passed to the call back function as
714 parameter.
715
716 @return EFI_UNSUPPORTED Isochronous transfer isn't supported.
717
718 **/
719 EFI_STATUS
720 EFIAPI
721 XhcAsyncIsochronousTransfer (
722 IN EFI_USB2_HC_PROTOCOL *This,
723 IN UINT8 DeviceAddress,
724 IN UINT8 EndPointAddress,
725 IN UINT8 DeviceSpeed,
726 IN UINTN MaximumPacketLength,
727 IN UINT8 DataBuffersNumber,
728 IN OUT VOID *Data[EFI_USB_MAX_ISO_BUFFER_NUM],
729 IN UINTN DataLength,
730 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
731 IN EFI_ASYNC_USB_TRANSFER_CALLBACK IsochronousCallBack,
732 IN VOID *Context
733 );
734
735 #endif