| /*++ | |
| Copyright (c) 2006 - 2007, Intel Corporation | |
| All rights reserved. This program and the accompanying materials | |
| are licensed and made available under the terms and conditions of the BSD License | |
| which accompanies this distribution. The full text of the license may be found at | |
| http://opensource.org/licenses/bsd-license.php | |
| THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| Module Name: | |
| Ehci.h | |
| Abstract: | |
| Revision History | |
| --*/ | |
| #ifndef _EHCI_H | |
| #define _EHCI_H | |
| // | |
| // Universal Host Controller Interface data structures and defines | |
| // | |
| #include <IndustryStandard/pci22.h> | |
| extern UINTN gEHCDebugLevel; | |
| extern UINTN gEHCErrorLevel; | |
| #define STALL_1_MACRO_SECOND 1 | |
| #define STALL_1_MILLI_SECOND 1000 * STALL_1_MACRO_SECOND | |
| #define STALL_1_SECOND 1000 * STALL_1_MILLI_SECOND | |
| #define MEM_UNIT_SIZE 128 | |
| #define SETUP_PACKET_PID_CODE 0x02 | |
| #define INPUT_PACKET_PID_CODE 0x01 | |
| #define OUTPUT_PACKET_PID_CODE 0x0 | |
| #define ITD_SELECT_TYPE 0x0 | |
| #define QH_SELECT_TYPE 0x01 | |
| #define SITD_SELECT_TYPE 0x02 | |
| #define FSTN_SELECT_TYPE 0x03 | |
| #define EHCI_SET_PORT_RESET_RECOVERY_TIME 50 * STALL_1_MILLI_SECOND | |
| #define EHCI_CLEAR_PORT_RESET_RECOVERY_TIME STALL_1_MILLI_SECOND | |
| #define EHCI_GENERIC_TIMEOUT 50 * STALL_1_MILLI_SECOND | |
| #define EHCI_GENERIC_RECOVERY_TIME 50 * STALL_1_MACRO_SECOND | |
| #define EHCI_SYNC_REQUEST_POLLING_TIME 50 * STALL_1_MACRO_SECOND | |
| #define EHCI_ASYNC_REQUEST_POLLING_TIME 50 * STALL_1_MILLI_SECOND | |
| #define USB_BAR_INDEX 0 /* how many bytes away from USB_BASE to 0x10 */ | |
| #define NORMAL_MEMORY_BLOCK_UNIT_IN_PAGES 16 | |
| #define EHCI_MIN_PACKET_SIZE 8 | |
| #define EHCI_MAX_PACKET_SIZE 1024 | |
| #define EHCI_MAX_FRAME_LIST_LENGTH 1024 | |
| #define EHCI_BLOCK_SIZE_WITH_TT 64 | |
| #define EHCI_BLOCK_SIZE 512 | |
| #define EHCI_MAX_QTD_CAPACITY (EFI_PAGE_SIZE * 5) | |
| #define NAK_COUNT_RELOAD 3 | |
| #define QTD_ERROR_COUNTER 3 | |
| #define HIGH_BANDWIDTH_PIPE_MULTIPLIER 1 | |
| #define QTD_STATUS_ACTIVE 0x80 | |
| #define QTD_STATUS_HALTED 0x40 | |
| #define QTD_STATUS_BUFFER_ERR 0x20 | |
| #define QTD_STATUS_BABBLE_ERR 0x10 | |
| #define QTD_STATUS_TRANSACTION_ERR 0x08 | |
| #define QTD_STATUS_DO_STOP_SPLIT 0x02 | |
| #define QTD_STATUS_DO_START_SPLIT 0 | |
| #define QTD_STATUS_DO_PING 0x01 | |
| #define QTD_STATUS_DO_OUT 0 | |
| #define DATA0 0 | |
| #define DATA1 1 | |
| #define MICRO_FRAME_0_CHANNEL 0x01 | |
| #define MICRO_FRAME_1_CHANNEL 0x02 | |
| #define MICRO_FRAME_2_CHANNEL 0x04 | |
| #define MICRO_FRAME_3_CHANNEL 0x08 | |
| #define MICRO_FRAME_4_CHANNEL 0x10 | |
| #define MICRO_FRAME_5_CHANNEL 0x20 | |
| #define MICRO_FRAME_6_CHANNEL 0x40 | |
| #define MICRO_FRAME_7_CHANNEL 0x80 | |
| #define CONTROL_TRANSFER 0x01 | |
| #define BULK_TRANSFER 0x02 | |
| #define SYNC_INTERRUPT_TRANSFER 0x04 | |
| #define ASYNC_INTERRUPT_TRANSFER 0x08 | |
| #define SYNC_ISOCHRONOUS_TRANSFER 0x10 | |
| #define ASYNC_ISOCHRONOUS_TRANSFER 0x20 | |
| // | |
| // Enhanced Host Controller Registers definitions | |
| // | |
| extern EFI_DRIVER_BINDING_PROTOCOL gEhciDriverBinding; | |
| extern EFI_COMPONENT_NAME_PROTOCOL gEhciComponentName; | |
| #define USBCMD 0x0 /* Command Register Offset 00-03h */ | |
| #define USBCMD_RS 0x01 /* Run / Stop */ | |
| #define USBCMD_HCRESET 0x02 /* Host controller reset */ | |
| #define USBCMD_FLS_512 0x04 /* 512 elements (2048bytes) in Frame List */ | |
| #define USBCMD_FLS_256 0x08 /* 256 elements (1024bytes) in Frame List */ | |
| #define USBCMD_PSE 0x10 /* Periodic schedule enable */ | |
| #define USBCMD_ASE 0x20 /* Asynchronous schedule enable */ | |
| #define USBCMD_IAAD 0x40 /* Interrupt on async advance doorbell */ | |
| #define USBSTS 0x04 /* Statue Register Offset 04-07h */ | |
| #define USBSTS_HSE 0x10 /* Host system error */ | |
| #define USBSTS_IAA 0x20 /* Interrupt on async advance */ | |
| #define USBSTS_HCH 0x1000 /* Host controller halted */ | |
| #define USBSTS_PSS 0x4000 /* Periodic schedule status */ | |
| #define USBSTS_ASS 0x8000 /* Asynchronous schedule status */ | |
| #define USBINTR 0x08 /* Command Register Offset 08-0bh */ | |
| #define FRINDEX 0x0c /* Frame Index Offset 0c-0fh */ | |
| #define CTRLDSSGMENT 0x10 /* 4G Segment Selector Offset 10-13h */ | |
| #define PERIODICLISTBASE 0x14 /* Frame List Base Address Offset 14-17h */ | |
| #define ASYNCLISTADDR 0x18 /* Next Asynchronous List Address Offset 18-1bh */ | |
| #define CONFIGFLAG 0x40 /* Configured Flag Register Offset 40-43h */ | |
| #define CONFIGFLAG_CF 0x01 /* Configure Flag */ | |
| #define PORTSC 0x44 /* Port Status/Control Offset 44-47h */ | |
| #define PORTSC_CCS 0x01 /* Current Connect Status*/ | |
| #define PORTSC_CSC 0x02 /* Connect Status Change */ | |
| #define PORTSC_PED 0x04 /* Port Enable / Disable */ | |
| #define PORTSC_PEDC 0x08 /* Port Enable / Disable Change */ | |
| #define PORTSC_OCA 0x10 /* Over current Active */ | |
| #define PORTSC_OCC 0x20 /* Over current Change */ | |
| #define PORTSC_FPR 0x40 /* Force Port Resume */ | |
| #define PORTSC_SUSP 0x80 /* Port Suspend State */ | |
| #define PORTSC_PR 0x100 /* Port Reset */ | |
| #define PORTSC_LS_KSTATE 0x400 /* Line Status K-state */ | |
| #define PORTSC_LS_JSTATE 0x800 /* Line Status J-state */ | |
| #define PORTSC_PP 0x1000 /* Port Power */ | |
| #define PORTSC_PO 0x2000 /* Port Owner */ | |
| #define CAPLENGTH 0 /* Capability Register Length 00h */ | |
| #define HCIVERSION 0x02 /* Interface Version Number 02-03h */ | |
| #define HCSPARAMS 0x04 /* Structural Parameters 04-07h */ | |
| #define HCSP_NPORTS 0x0f /* Number of physical downstream ports on host controller */ | |
| #define HCCPARAMS 0x08 /* Capability Parameters 08-0bh */ | |
| #define HCCP_64BIT 0x01 /* 64-bit Addressing Capability */ | |
| #define HCCP_PFLF 0x02 /* Programmable Frame List Flag */ | |
| #define HCCP_EECP 0xff00 /* EHCI Extemded Capabilities Pointer */ | |
| #define HCSPPORTROUTE 0x0c /* Companion Port Route Description 60b */ | |
| #define CLASSC 0x09 /* Class Code 09-0bh */ | |
| #define USBBASE 0x10 /* Base Address to Memory-mapped Host Controller Register Space 10-13h */ | |
| #define SBRN 0x60 /* Serial Bus Release Number 60h */ | |
| #define FLADJ 0x61 /* Frame Length Adjustment Register 61h */ | |
| #define PORTWAKECAP 0x62 /* Port wake capablilities register(OPIONAL) 61-62h */ | |
| // | |
| // PCI Configuration Registers | |
| // | |
| #define EHCI_PCI_CLASSC 0x09 | |
| #define EHCI_PCI_MEMORY_BASE 0x10 | |
| // | |
| // Memory Offset Registers | |
| // | |
| #define EHCI_MEMORY_CAPLENGTH 0x0 | |
| #define EHCI_MEMORY_CONFIGFLAG 0x40 | |
| // | |
| // USB Base Class Code,Sub-Class Code and Programming Interface | |
| // | |
| #define PCI_CLASSC_PI_EHCI PCI_IF_EHCI | |
| #define SETUP_PACKET_ID 0x2D | |
| #define INPUT_PACKET_ID 0x69 | |
| #define OUTPUT_PACKET_ID 0xE1 | |
| #define ERROR_PACKET_ID 0x55 | |
| #define bit(a) (1 << (a)) | |
| #define GET_0B_TO_31B(Addr) (((UINTN) Addr) & (0xffffffff)) | |
| #define GET_32B_TO_63B(Addr) ((UINTN)RShiftU64((UINTN) Addr, 32) & (0xffffffff)) | |
| // | |
| // Ehci Data and Ctrl Structures | |
| // | |
| #pragma pack(1) | |
| typedef struct { | |
| UINT8 PI; | |
| UINT8 SubClassCode; | |
| UINT8 BaseCode; | |
| } USB_CLASSC; | |
| // | |
| //32 Bytes Aligned | |
| // | |
| typedef struct { | |
| UINT32 NextQtdTerminate : 1; | |
| UINT32 Rsvd1 : 4; | |
| UINT32 NextQtdPointer : 27; | |
| UINT32 AltNextQtdTerminate : 1; | |
| UINT32 Rsvd2 : 4; | |
| UINT32 AltNextQtdPointer : 27; | |
| UINT32 Status : 8; | |
| UINT32 PidCode : 2; | |
| UINT32 ErrorCount : 2; | |
| UINT32 CurrentPage : 3; | |
| UINT32 InterruptOnComplete : 1; | |
| UINT32 TotalBytes : 15; | |
| UINT32 DataToggle : 1; | |
| UINT32 CurrentOffset : 12; | |
| UINT32 BufferPointer0 : 20; | |
| UINT32 Rsvd3 : 12; | |
| UINT32 BufferPointer1 : 20; | |
| UINT32 Rsvd4 : 12; | |
| UINT32 BufferPointer2 : 20; | |
| UINT32 Rsvd5 : 12; | |
| UINT32 BufferPointer3 : 20; | |
| UINT32 Rsvd6 : 12; | |
| UINT32 BufferPointer4 : 20; | |
| UINT32 PAD[5]; | |
| } EHCI_QTD_HW; | |
| // | |
| //32 Bytes Aligned | |
| // | |
| typedef struct { | |
| UINT32 QhTerminate : 1; | |
| UINT32 SelectType : 2; | |
| UINT32 Rsvd1 : 2; | |
| UINT32 QhHorizontalPointer : 27; | |
| UINT32 DeviceAddr : 7; | |
| UINT32 Inactive : 1; | |
| UINT32 EndpointNum : 4; | |
| UINT32 EndpointSpeed : 2; | |
| UINT32 DataToggleControl : 1; | |
| UINT32 HeadReclamationFlag : 1; | |
| UINT32 MaxPacketLen : 11; | |
| UINT32 ControlEndpointFlag : 1; | |
| UINT32 NakCountReload : 4; | |
| UINT32 InerruptScheduleMask : 8; | |
| UINT32 SplitComletionMask : 8; | |
| UINT32 HubAddr : 7; | |
| UINT32 PortNum : 7; | |
| UINT32 Multiplier : 2; | |
| UINT32 Rsvd2 : 5; | |
| UINT32 CurrentQtdPointer : 27; | |
| UINT32 NextQtdTerminate : 1; | |
| UINT32 Rsvd3 : 4; | |
| UINT32 NextQtdPointer : 27; | |
| UINT32 AltNextQtdTerminate : 1; | |
| UINT32 NakCount : 4; | |
| UINT32 AltNextQtdPointer : 27; | |
| UINT32 Status : 8; | |
| UINT32 PidCode : 2; | |
| UINT32 ErrorCount : 2; | |
| UINT32 CurrentPage : 3; | |
| UINT32 InterruptOnComplete : 1; | |
| UINT32 TotalBytes : 15; | |
| UINT32 DataToggle : 1; | |
| UINT32 CurrentOffset : 12; | |
| UINT32 BufferPointer0 : 20; | |
| UINT32 CompleteSplitMask : 8; | |
| UINT32 Rsvd4 : 4; | |
| UINT32 BufferPointer1 : 20; | |
| UINT32 FrameTag : 5; | |
| UINT32 SplitBytes : 7; | |
| UINT32 BufferPointer2 : 20; | |
| UINT32 Rsvd5 : 12; | |
| UINT32 BufferPointer3 : 20; | |
| UINT32 Rsvd6 : 12; | |
| UINT32 BufferPointer4 : 20; | |
| UINT32 Pad[5]; | |
| } EHCI_QH_HW; | |
| typedef struct { | |
| UINT32 LinkTerminate : 1; | |
| UINT32 SelectType : 2; | |
| UINT32 Rsvd : 2; | |
| UINT32 LinkPointer : 27; | |
| } FRAME_LIST_ENTRY; | |
| #pragma pack() | |
| typedef struct _EHCI_QTD_ENTITY EHCI_QTD_ENTITY; | |
| typedef struct _EHCI_QH_ENTITY EHCI_QH_ENTITY; | |
| typedef struct _EHCI_ASYNC_REQUEST EHCI_ASYNC_REQUEST; | |
| // | |
| //Aligan On 32 Bytes | |
| // | |
| struct _EHCI_QTD_ENTITY { | |
| EHCI_QTD_HW Qtd; | |
| UINT32 TotalBytes; | |
| UINT32 StaticTotalBytes; | |
| UINT32 StaticCurrentOffset; | |
| EHCI_QTD_ENTITY *Prev; | |
| EHCI_QTD_ENTITY *Next; | |
| EHCI_QTD_ENTITY *AltNext; | |
| EHCI_QH_ENTITY *SelfQh; | |
| }; | |
| // | |
| //Aligan On 32 Bytes | |
| // | |
| struct _EHCI_QH_ENTITY { | |
| EHCI_QH_HW Qh; | |
| EHCI_QH_ENTITY *Next; | |
| EHCI_QH_ENTITY *Prev; | |
| EHCI_QTD_ENTITY *FirstQtdPtr; | |
| EHCI_QTD_ENTITY *LastQtdPtr; | |
| EHCI_QTD_ENTITY *AltQtdPtr; | |
| UINTN Interval; | |
| UINT8 TransferType; | |
| }; | |
| #define GET_QH_ENTITY_ADDR(a) ((EHCI_QH_ENTITY *) a) | |
| #define GET_QTD_ENTITY_ADDR(a) ((EHCI_QTD_ENTITY *) a) | |
| // | |
| // Ehci Managment Structures | |
| // | |
| #define USB2_HC_DEV_FROM_THIS(a) CR (a, USB2_HC_DEV, Usb2Hc, USB2_HC_DEV_SIGNATURE) | |
| #define USB2_HC_DEV_SIGNATURE EFI_SIGNATURE_32 ('e', 'h', 'c', 'i') | |
| struct _EHCI_ASYNC_REQUEST { | |
| UINT8 TransferType; | |
| EFI_ASYNC_USB_TRANSFER_CALLBACK CallBackFunc; | |
| VOID *Context; | |
| EHCI_ASYNC_REQUEST *Prev; | |
| EHCI_ASYNC_REQUEST *Next; | |
| EHCI_QH_ENTITY *QhPtr; | |
| }; | |
| typedef struct _MEMORY_MANAGE_HEADER { | |
| UINT8 *BitArrayPtr; | |
| UINTN BitArraySizeInBytes; | |
| UINT8 *MemoryBlockPtr; | |
| UINTN MemoryBlockSizeInBytes; | |
| VOID *Mapping; | |
| struct _MEMORY_MANAGE_HEADER *Next; | |
| } MEMORY_MANAGE_HEADER; | |
| typedef struct _USB2_HC_DEV { | |
| UINTN Signature; | |
| EFI_PCI_IO_PROTOCOL *PciIo; | |
| EFI_USB2_HC_PROTOCOL Usb2Hc; | |
| UINTN PeriodicFrameListLength; | |
| VOID *PeriodicFrameListBuffer; | |
| VOID *PeriodicFrameListMap; | |
| VOID *AsyncList; | |
| EHCI_ASYNC_REQUEST *AsyncRequestList; | |
| EFI_EVENT AsyncRequestEvent; | |
| EFI_UNICODE_STRING_TABLE *ControllerNameTable; | |
| MEMORY_MANAGE_HEADER *MemoryHeader; | |
| UINT8 Is64BitCapable; | |
| UINT32 High32BitAddr; | |
| EHCI_QH_ENTITY *NULLQH; | |
| UINT32 UsbCapabilityLen; | |
| UINT16 DeviceSpeed[16]; | |
| } USB2_HC_DEV; | |
| // | |
| // Prototypes | |
| // Driver model protocol interface | |
| // | |
| EFI_STATUS | |
| EFIAPI | |
| EhciDriverBindingSupported ( | |
| IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
| IN EFI_HANDLE Controller, | |
| IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciDriverBindingStart ( | |
| IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
| IN EFI_HANDLE Controller, | |
| IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciDriverBindingStop ( | |
| IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
| IN EFI_HANDLE Controller, | |
| IN UINTN NumberOfChildren, | |
| IN EFI_HANDLE *ChildHandleBuffer | |
| ); | |
| // | |
| // Ehci protocol interface | |
| // | |
| EFI_STATUS | |
| EFIAPI | |
| EhciGetCapability ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| OUT UINT8 *MaxSpeed, | |
| OUT UINT8 *PortNumber, | |
| OUT UINT8 *Is64BitCapable | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciReset ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT16 Attributes | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciGetState ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| OUT EFI_USB_HC_STATE *State | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciSetState ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN EFI_USB_HC_STATE State | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciControlTransfer ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 DeviceAddress, | |
| IN UINT8 DeviceSpeed, | |
| IN UINTN MaximumPacketLength, | |
| IN EFI_USB_DEVICE_REQUEST *Request, | |
| IN EFI_USB_DATA_DIRECTION TransferDirection, | |
| IN OUT VOID *Data, | |
| IN OUT UINTN *DataLength, | |
| IN UINTN TimeOut, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT UINT32 *TransferResult | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciBulkTransfer ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 DeviceAddress, | |
| IN UINT8 EndPointAddress, | |
| IN UINT8 DeviceSpeed, | |
| IN UINTN MaximumPacketLength, | |
| IN UINT8 DataBuffersNumber, | |
| IN OUT VOID *Data[EFI_USB_MAX_BULK_BUFFER_NUM], | |
| IN OUT UINTN *DataLength, | |
| IN OUT UINT8 *DataToggle, | |
| IN UINTN TimeOut, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT UINT32 *TransferResult | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciAsyncInterruptTransfer ( | |
| IN EFI_USB2_HC_PROTOCOL * This, | |
| IN UINT8 DeviceAddress, | |
| IN UINT8 EndPointAddress, | |
| IN UINT8 DeviceSpeed, | |
| IN UINTN MaxiumPacketLength, | |
| IN BOOLEAN IsNewTransfer, | |
| IN OUT UINT8 *DataToggle, | |
| IN UINTN PollingInterval, | |
| IN UINTN DataLength, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| IN EFI_ASYNC_USB_TRANSFER_CALLBACK CallBackFunction, | |
| IN VOID *Context OPTIONAL | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciSyncInterruptTransfer ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 DeviceAddress, | |
| IN UINT8 EndPointAddress, | |
| IN UINT8 DeviceSpeed, | |
| IN UINTN MaximumPacketLength, | |
| IN OUT VOID *Data, | |
| IN OUT UINTN *DataLength, | |
| IN OUT UINT8 *DataToggle, | |
| IN UINTN TimeOut, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT UINT32 *TransferResult | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciIsochronousTransfer ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 DeviceAddress, | |
| IN UINT8 EndPointAddress, | |
| IN UINT8 DeviceSpeed, | |
| IN UINTN MaximumPacketLength, | |
| IN UINT8 DataBuffersNumber, | |
| IN OUT VOID *Data[EFI_USB_MAX_ISO_BUFFER_NUM], | |
| IN UINTN DataLength, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT UINT32 *TransferResult | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciAsyncIsochronousTransfer ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 DeviceAddress, | |
| IN UINT8 EndPointAddress, | |
| IN UINT8 DeviceSpeed, | |
| IN UINTN MaximumPacketLength, | |
| IN UINT8 DataBuffersNumber, | |
| IN OUT VOID *Data[EFI_USB_MAX_ISO_BUFFER_NUM], | |
| IN UINTN DataLength, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| IN EFI_ASYNC_USB_TRANSFER_CALLBACK IsochronousCallBack, | |
| IN VOID *Context | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciGetRootHubPortStatus ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 PortNumber, | |
| OUT EFI_USB_PORT_STATUS *PortStatus | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciSetRootHubPortFeature ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 PortNumber, | |
| IN EFI_USB_PORT_FEATURE PortFeature | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciClearRootHubPortFeature ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 PortNumber, | |
| IN EFI_USB_PORT_FEATURE PortFeature | |
| ); | |
| // | |
| // EFI Component Name Functions | |
| // | |
| EFI_STATUS | |
| EFIAPI | |
| EhciComponentNameGetDriverName ( | |
| IN EFI_COMPONENT_NAME_PROTOCOL *This, | |
| IN CHAR8 *Language, | |
| OUT CHAR16 **DriverName | |
| ); | |
| EFI_STATUS | |
| EFIAPI | |
| EhciComponentNameGetControllerName ( | |
| IN EFI_COMPONENT_NAME_PROTOCOL *This, | |
| IN EFI_HANDLE ControllerHandle, | |
| IN EFI_HANDLE ChildHandle, OPTIONAL | |
| IN CHAR8 *Language, | |
| OUT CHAR16 **ControllerName | |
| ); | |
| // | |
| // Internal Functions Declaration | |
| // | |
| // | |
| // EhciMem Functions | |
| // | |
| EFI_STATUS | |
| CreateMemoryBlock ( | |
| IN USB2_HC_DEV *HcDev, | |
| OUT MEMORY_MANAGE_HEADER **MemoryHeader, | |
| IN UINTN MemoryBlockSizeInPages | |
| ) | |
| /*++ | |
| Routine Description: | |
| Use PciIo->AllocateBuffer to allocate common buffer for the memory block, | |
| and use PciIo->Map to map the common buffer for Bus Master Read/Write. | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| MemoryHeader - MEMORY_MANAGE_HEADER to output | |
| MemoryBlockSizeInPages - MemoryBlockSizeInPages | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_OUT_OF_RESOURCES Fail for no resources | |
| EFI_UNSUPPORTED Unsupported currently | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| FreeMemoryHeader ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN MEMORY_MANAGE_HEADER *MemoryHeader | |
| ) | |
| /*++ | |
| Routine Description: | |
| Free Memory Header | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| MemoryHeader - MemoryHeader to be freed | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_INVALID_PARAMETER Parameter is error | |
| --*/ | |
| ; | |
| VOID | |
| InsertMemoryHeaderToList ( | |
| IN MEMORY_MANAGE_HEADER *MemoryHeader, | |
| IN MEMORY_MANAGE_HEADER *NewMemoryHeader | |
| ) | |
| /*++ | |
| Routine Description: | |
| Insert Memory Header To List | |
| Arguments: | |
| MemoryHeader - MEMORY_MANAGE_HEADER | |
| NewMemoryHeader - MEMORY_MANAGE_HEADER | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| AllocMemInMemoryBlock ( | |
| IN MEMORY_MANAGE_HEADER *MemoryHeader, | |
| OUT VOID **Pool, | |
| IN UINTN NumberOfMemoryUnit | |
| ) | |
| /*++ | |
| Routine Description: | |
| Alloc Memory In MemoryBlock | |
| Arguments: | |
| MemoryHeader - MEMORY_MANAGE_HEADER | |
| Pool - Place to store pointer to memory | |
| NumberOfMemoryUnit - Number Of Memory Unit | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_NOT_FOUND Can't find the free memory | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsMemoryBlockEmptied ( | |
| IN MEMORY_MANAGE_HEADER *MemoryHeaderPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Is Memory Block Emptied | |
| Arguments: | |
| MemoryHeaderPtr - MEMORY_MANAGE_HEADER | |
| Returns: | |
| TRUE Empty | |
| FALSE Not Empty | |
| --*/ | |
| ; | |
| VOID | |
| DelinkMemoryBlock ( | |
| IN MEMORY_MANAGE_HEADER *FirstMemoryHeader, | |
| IN MEMORY_MANAGE_HEADER *NeedFreeMemoryHeader | |
| ) | |
| /*++ | |
| Routine Description: | |
| Delink Memory Block | |
| Arguments: | |
| FirstMemoryHeader - MEMORY_MANAGE_HEADER | |
| NeedFreeMemoryHeader - MEMORY_MANAGE_HEADER | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| InitialMemoryManagement ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Initialize Memory Management | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| DeinitialMemoryManagement ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Deinitialize Memory Management | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| EhciAllocatePool ( | |
| IN USB2_HC_DEV *HcDev, | |
| OUT UINT8 **Pool, | |
| IN UINTN AllocSize | |
| ) | |
| /*++ | |
| Routine Description: | |
| Ehci Allocate Pool | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Pool - Place to store pointer to the memory buffer | |
| AllocSize - Alloc Size | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| VOID | |
| EhciFreePool ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 *Pool, | |
| IN UINTN AllocSize | |
| ) | |
| /*++ | |
| Routine Description: | |
| Uhci Free Pool | |
| Arguments: | |
| HcDev - USB_HC_DEV | |
| Pool - Pool to free | |
| AllocSize - Pool size | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| // | |
| // EhciReg Functions | |
| // | |
| EFI_STATUS | |
| ReadEhcCapabiltiyReg ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT32 CapabiltiyRegAddr, | |
| IN OUT UINT32 *Data | |
| ) | |
| /*++ | |
| Routine Description: | |
| Read Ehc Capabitlity register | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| CapabiltiyRegAddr - Ehc Capability register address | |
| Data - A pointer to data read from register | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| ReadEhcOperationalReg ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT32 OperationalRegAddr, | |
| IN OUT UINT32 *Data | |
| ) | |
| /*++ | |
| Routine Description: | |
| Read Ehc Operation register | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| OperationalRegAddr - Ehc Operation register address | |
| Data - A pointer to data read from register | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WriteEhcOperationalReg ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT32 OperationalRegAddr, | |
| IN UINT32 Data | |
| ) | |
| /*++ | |
| Routine Description: | |
| Write Ehc Operation register | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| OperationalRegAddr - Ehc Operation register address | |
| Data - 32bit write to register | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| SetEhcDoorbell ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Set Ehc door bell bit | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| SetFrameListLen ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Length | |
| ) | |
| /*++ | |
| Routine Description: | |
| Set the length of Frame List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Length - the required length of frame list | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_INVALID_PARAMETER Invalid parameter | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsFrameListProgrammable ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether frame list is programmable | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| TRUE Programmable | |
| FALSE Unprogrammable | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsPeriodicScheduleEnabled ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether periodic schedule is enabled | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| TRUE Enabled | |
| FALSE Disabled | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsAsyncScheduleEnabled ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether asynchronous schedule is enabled | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| TRUE Enabled | |
| FALSE Disabled | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsEhcPortEnabled ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 PortNum | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether port is enabled | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| TRUE Enabled | |
| FALSE Disabled | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsEhcReseted ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether Ehc is halted | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| TRUE Reseted | |
| FALSE Unreseted | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsEhcHalted ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether Ehc is halted | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| TRUE Halted | |
| FALSE Not halted | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsEhcSysError ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether Ehc is system error | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| TRUE System error | |
| FALSE No system error | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsHighSpeedDevice ( | |
| IN EFI_USB2_HC_PROTOCOL *This, | |
| IN UINT8 PortNum | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether high speed device attached | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| TRUE High speed | |
| FALSE Full speed | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WaitForEhcReset ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Timeout | |
| ) | |
| /*++ | |
| Routine Description: | |
| wait for Ehc reset or timeout | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Timeout - timeout threshold | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_TIMEOUT Timeout | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WaitForEhcHalt ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Timeout | |
| ) | |
| /*++ | |
| Routine Description: | |
| wait for Ehc halt or timeout | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Timeout - timeout threshold | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_TIMEOUT Timeout | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WaitForEhcNotHalt ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Timeout | |
| ) | |
| /*++ | |
| Routine Description: | |
| wait for Ehc not halt or timeout | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Timeout - timeout threshold | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_TIMEOUT Timeout | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WaitForEhcDoorbell ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Timeout | |
| ) | |
| /*++ | |
| Routine Description: | |
| Wait for periodic schedule disable or timeout | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Timeout - timeout threshold | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_TIMEOUT Timeout | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WaitForAsyncScheduleEnable ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Timeout | |
| ) | |
| /*++ | |
| Routine Description: | |
| Wait for Ehc asynchronous schedule enable or timeout | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Timeout - timeout threshold | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_TIMEOUT Timeout | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WaitForAsyncScheduleDisable ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Timeout | |
| ) | |
| /*++ | |
| Routine Description: | |
| Wait for Ehc asynchronous schedule disable or timeout | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Timeout - timeout threshold | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_TIMEOUT Timeout | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WaitForPeriodicScheduleEnable ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Timeout | |
| ) | |
| /*++ | |
| Routine Description: | |
| Wait for Ehc periodic schedule enable or timeout | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Timeout - timeout threshold | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_TIMEOUT Timeout | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| WaitForPeriodicScheduleDisable ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Timeout | |
| ) | |
| /*++ | |
| Routine Description: | |
| Wait for periodic schedule disable or timeout | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Timeout - timeout threshold | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_TIMEOUT Timeout | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| GetCapabilityLen ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Get the length of capability register | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| SetFrameListBaseAddr ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT32 FrameBuffer | |
| ) | |
| /*++ | |
| Routine Description: | |
| Set base address of frame list first entry | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| FrameBuffer - base address of first entry of frame list | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| SetAsyncListAddr ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_QH_ENTITY *QhPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Set address of first Async schedule Qh | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| QhPtr - A pointer to first Qh in the Async schedule | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| SetCtrlDataStructSeg ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Set address of first Async schedule Qh | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| QhPtr - A pointer to first Qh in the Async schedule | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| SetPortRoutingEhc ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Set Ehc port routing bit | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| EnablePeriodicSchedule ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Enable periodic schedule | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| DisablePeriodicSchedule ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Disable periodic schedule | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| EnableAsynchronousSchedule ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Enable asynchrounous schedule | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| DisableAsynchronousSchedule ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Disable asynchrounous schedule | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| StartScheduleExecution ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Start Ehc schedule execution | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| ResetEhc ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Reset Ehc | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| ClearEhcAllStatus ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Clear Ehc all status bits | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| // | |
| // EhciSched Functions | |
| // | |
| EFI_STATUS | |
| InitialPeriodicFrameList ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINTN Length | |
| ) | |
| /*++ | |
| Routine Description: | |
| Initialize Periodic Schedule Frame List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Length - Frame List Length | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| VOID | |
| DeinitialPeriodicFrameList ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Deinitialize Periodic Schedule Frame List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreatePollingTimer ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EFI_EVENT_NOTIFY NotifyFunction | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Async Request Polling Timer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| NotifyFunction - Timer Notify Function | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| DestoryPollingTimer ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Destory Async Request Polling Timer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| StartPollingTimer ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Start Async Request Polling Timer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| StopPollingTimer ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Stop Async Request Polling Timer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateQh ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 DeviceAddr, | |
| IN UINT8 Endpoint, | |
| IN UINT8 DeviceSpeed, | |
| IN UINTN MaxPacketLen, | |
| OUT EHCI_QH_ENTITY **QhPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qh Structure and Pre-Initialize | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DeviceAddr - Address of Device | |
| Endpoint - Endpoint Number | |
| DeviceSpeed - Device Speed | |
| MaxPacketLen - Max Length of one Packet | |
| QhPtrPtr - A pointer of pointer to Qh for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateControlQh ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 DeviceAddr, | |
| IN UINT8 DeviceSpeed, | |
| IN UINTN MaxPacketLen, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT EHCI_QH_ENTITY **QhPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qh for Control Transfer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DeviceAddr - Address of Device | |
| DeviceSpeed - Device Speed | |
| MaxPacketLen - Max Length of one Packet | |
| Translator - Translator Transaction for SplitX | |
| QhPtrPtr - A pointer of pointer to Qh for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateBulkQh ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 DeviceAddr, | |
| IN UINT8 EndPointAddr, | |
| IN UINT8 DeviceSpeed, | |
| IN UINT8 DataToggle, | |
| IN UINTN MaxPacketLen, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT EHCI_QH_ENTITY **QhPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qh for Bulk Transfer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DeviceAddr - Address of Device | |
| EndPointAddr - Address of Endpoint | |
| DeviceSpeed - Device Speed | |
| MaxPacketLen - Max Length of one Packet | |
| Translator - Translator Transaction for SplitX | |
| QhPtrPtr - A pointer of pointer to Qh for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateInterruptQh ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 DeviceAddr, | |
| IN UINT8 EndPointAddr, | |
| IN UINT8 DeviceSpeed, | |
| IN UINT8 DataToggle, | |
| IN UINTN MaxPacketLen, | |
| IN UINTN Interval, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT EHCI_QH_ENTITY **QhPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qh for Control Transfer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DeviceAddr - Address of Device | |
| EndPointAddr - Address of Endpoint | |
| DeviceSpeed - Device Speed | |
| MaxPacketLen - Max Length of one Packet | |
| Interval - value of interval | |
| Translator - Translator Transaction for SplitX | |
| QhPtrPtr - A pointer of pointer to Qh for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| VOID | |
| DestoryQh ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_QH_ENTITY *QhPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Destory Qh Structure | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| QhPtr - A pointer to Qh | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateQtd ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 *DataPtr, | |
| IN UINTN DataLen, | |
| IN UINT8 PktId, | |
| IN UINT8 Toggle, | |
| IN UINT8 QtdStatus, | |
| OUT EHCI_QTD_ENTITY **QtdPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qtd Structure and Pre-Initialize it | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DataPtr - A pointer to user data buffer to transfer | |
| DataLen - Length of user data to transfer | |
| PktId - Packet Identification of this Qtd | |
| Toggle - Data Toggle of this Qtd | |
| QtdStatus - Default value of status of this Qtd | |
| QtdPtrPtr - A pointer of pointer to Qtd for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_OUT_OF_RESOURCES Cannot allocate resources | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateSetupQtd ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 *DevReqPtr, | |
| OUT EHCI_QTD_ENTITY **QtdPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qtd Structure for Setup | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DevReqPtr - A pointer to Device Request Data | |
| QtdPtrPtr - A pointer of pointer to Qtd for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_OUT_OF_RESOURCES Cannot allocate resources | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateDataQtd ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 *DataPtr, | |
| IN UINTN DataLen, | |
| IN UINT8 PktId, | |
| IN UINT8 Toggle, | |
| OUT EHCI_QTD_ENTITY **QtdPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qtd Structure for data | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DataPtr - A pointer to user data buffer to transfer | |
| DataLen - Length of user data to transfer | |
| PktId - Packet Identification of this Qtd | |
| Toggle - Data Toggle of this Qtd | |
| QtdPtrPtr - A pointer of pointer to Qtd for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_OUT_OF_RESOURCES Cannot allocate resources | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateStatusQtd ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 PktId, | |
| OUT EHCI_QTD_ENTITY **QtdPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qtd Structure for status | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| PktId - Packet Identification of this Qtd | |
| QtdPtrPtr - A pointer of pointer to Qtd for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_OUT_OF_RESOURCES Cannot allocate resources | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateAltQtd ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 PktId, | |
| OUT EHCI_QTD_ENTITY **QtdPtrPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qtd Structure for Alternative | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| PktId - Packet Identification of this Qtd | |
| QtdPtrPtr - A pointer of pointer to Qtd for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_OUT_OF_RESOURCES Cannot allocate resources | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateControlQtds ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 DataPktId, | |
| IN UINT8 *RequestCursor, | |
| IN UINT8 *DataCursor, | |
| IN UINTN DataLen, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT EHCI_QTD_ENTITY **ControlQtdsHead | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qtds list for Control Transfer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DataPktId - Packet Identification of Data Qtds | |
| RequestCursor - A pointer to request structure buffer to transfer | |
| DataCursor - A pointer to user data buffer to transfer | |
| DataLen - Length of user data to transfer | |
| ControlQtdsHead - A pointer of pointer to first Qtd for control tranfer for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateBulkOrInterruptQtds ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 PktId, | |
| IN UINT8 *DataCursor, | |
| IN UINTN DataLen, | |
| IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator, | |
| OUT EHCI_QTD_ENTITY **QtdsHead | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create Qtds list for Bulk or Interrupt Transfer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| PktId - Packet Identification of Qtds | |
| DataCursor - A pointer to user data buffer to transfer | |
| DataLen - Length of user data to transfer | |
| DataToggle - Data Toggle to start | |
| Translator - Translator Transaction for SplitX | |
| QtdsHead - A pointer of pointer to first Qtd for control tranfer for return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| VOID | |
| DestoryQtds ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_QTD_ENTITY *FirstQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Destory all Qtds in the list | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| FirstQtdPtr - A pointer to first Qtd in the list | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| VOID | |
| LinkQtdToQtd ( | |
| IN EHCI_QTD_ENTITY *PreQtdPtr, | |
| IN EHCI_QTD_ENTITY *QtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Link Qtds together | |
| Arguments: | |
| PreQtdPtr - A pointer to pre Qtd | |
| QtdPtr - A pointer to next Qtd | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| VOID | |
| LinkQtdsToAltQtd ( | |
| IN EHCI_QTD_ENTITY *FirstQtdPtr, | |
| IN EHCI_QTD_ENTITY *AltQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Link AlterQtds together | |
| Arguments: | |
| FirstQtdPtr - A pointer to first Qtd in the list | |
| AltQtdPtr - A pointer to alternative Qtd | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| VOID | |
| LinkQtdToQh ( | |
| IN EHCI_QH_ENTITY *QhPtr, | |
| IN EHCI_QTD_ENTITY *QtdEntryPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Link Qtds list to Qh | |
| Arguments: | |
| QhPtr - A pointer to Qh | |
| QtdPtr - A pointer to first Qtd in the list | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| LinkQhToAsyncList ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_QH_ENTITY *QhPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Link Qh to Async Schedule List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| QhPtr - A pointer to Qh | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| UnlinkQhFromAsyncList ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_QH_ENTITY *QhPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Unlink Qh from Async Schedule List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| QhPtr - A pointer to Qh | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| VOID | |
| LinkQhToPeriodicList ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_QH_ENTITY *QhPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Link Qh to Periodic Schedule List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| QhPtr - A pointer to Qh | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| VOID | |
| UnlinkQhFromPeriodicList ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_QH_ENTITY *QhPtr, | |
| IN UINTN Interval | |
| ) | |
| /*++ | |
| Routine Description: | |
| Unlink Qh from Periodic Schedule List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| QhPtr - A pointer to Qh | |
| Interval - Interval of this periodic transfer | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| VOID | |
| LinkToAsyncReqeust ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_ASYNC_REQUEST *AsyncRequestPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Llink AsyncRequest Entry to Async Request List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| AsyncRequestPtr - A pointer to Async Request Entry | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| VOID | |
| UnlinkFromAsyncReqeust ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EHCI_ASYNC_REQUEST *AsyncRequestPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Unlink AsyncRequest Entry from Async Request List | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| AsyncRequestPtr - A pointer to Async Request Entry | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| UINTN | |
| GetNumberOfQtd ( | |
| IN EHCI_QTD_ENTITY *FirstQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Number of Qtds in the list | |
| Arguments: | |
| FirstQtdPtr - A pointer to first Qtd in the list | |
| Returns: | |
| Number of Qtds in the list | |
| --*/ | |
| ; | |
| UINTN | |
| GetCapacityOfQtd ( | |
| IN UINT8 *BufferCursor | |
| ) | |
| /*++ | |
| Routine Description: | |
| Get Capacity of Qtd | |
| Arguments: | |
| BufferCursor - BufferCursor of the Qtd | |
| Returns: | |
| Capacity of Qtd | |
| --*/ | |
| ; | |
| UINTN | |
| GetApproxiOfInterval ( | |
| IN UINTN Interval | |
| ) | |
| /*++ | |
| Routine Description: | |
| Get the approximate value in the 2 index sequence | |
| Arguments: | |
| Interval - the value of interval | |
| Returns: | |
| approximate value of interval in the 2 index sequence | |
| --*/ | |
| ; | |
| EHCI_QTD_HW * | |
| GetQtdNextPointer ( | |
| IN EHCI_QTD_HW *HwQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Get Qtd next pointer field | |
| Arguments: | |
| HwQtdPtr - A pointer to hardware Qtd structure | |
| Returns: | |
| A pointer to next hardware Qtd structure | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsQtdStatusActive ( | |
| IN EHCI_QTD_HW *HwQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether Qtd status is active or not | |
| Arguments: | |
| HwQtdPtr - A pointer to hardware Qtd structure | |
| Returns: | |
| TRUE Active | |
| FALSE Inactive | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsQtdStatusHalted ( | |
| IN EHCI_QTD_HW *HwQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether Qtd status is halted or not | |
| Arguments: | |
| HwQtdPtr - A pointer to hardware Qtd structure | |
| Returns: | |
| TRUE Halted | |
| FALSE Not halted | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsQtdStatusBufferError ( | |
| IN EHCI_QTD_HW *HwQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether Qtd status is buffer error or not | |
| Arguments: | |
| HwQtdPtr - A pointer to hardware Qtd structure | |
| Returns: | |
| TRUE Buffer error | |
| FALSE No buffer error | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsQtdStatusBabbleError ( | |
| IN EHCI_QTD_HW *HwQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether Qtd status is babble error or not | |
| Arguments: | |
| HwQtdPtr - A pointer to hardware Qtd structure | |
| Returns: | |
| TRUE Babble error | |
| FALSE No babble error | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsQtdStatusTransactionError ( | |
| IN EHCI_QTD_HW *HwQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether Qtd status is transaction error or not | |
| Arguments: | |
| HwQtdPtr - A pointer to hardware Qtd structure | |
| Returns: | |
| TRUE Transaction error | |
| FALSE No transaction error | |
| --*/ | |
| ; | |
| BOOLEAN | |
| IsDataInTransfer ( | |
| IN UINT8 EndPointAddress | |
| ) | |
| /*++ | |
| Routine Description: | |
| Whether is a DataIn direction transfer | |
| Arguments: | |
| EndPointAddress - address of the endpoint | |
| Returns: | |
| TRUE DataIn | |
| FALSE DataOut | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| MapDataBuffer ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN EFI_USB_DATA_DIRECTION TransferDirection, | |
| IN OUT VOID *Data, | |
| IN OUT UINTN *DataLength, | |
| OUT UINT8 *PktId, | |
| OUT UINT8 **DataCursor, | |
| OUT VOID **DataMap | |
| ) | |
| /*++ | |
| Routine Description: | |
| Map address of user data buffer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| TransferDirection - direction of transfer | |
| Data - A pointer to user data buffer | |
| DataLength - length of user data | |
| PktId - Packte Identificaion | |
| DataCursor - mapped address to return | |
| DataMap - identificaion of this mapping to return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| MapRequestBuffer ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN OUT VOID *Request, | |
| OUT UINT8 **RequestCursor, | |
| OUT VOID **RequestMap | |
| ) | |
| /*++ | |
| Routine Description: | |
| Map address of request structure buffer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Request - A pointer to request structure | |
| RequestCursor - Mapped address of request structure to return | |
| RequestMap - Identificaion of this mapping to return | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| VOID | |
| SetQtdBufferPointer ( | |
| IN EHCI_QTD_HW *QtdHwPtr, | |
| IN VOID *DataPtr, | |
| IN UINTN DataLen | |
| ) | |
| /*++ | |
| Routine Description: | |
| Set data buffer pointers in Qtd | |
| Arguments: | |
| QtdHwPtr - A pointer to Qtd hardware structure | |
| DataPtr - A pointer to user data buffer | |
| DataLen - Length of the user data buffer | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| EHCI_QTD_HW * | |
| GetQtdAlternateNextPointer ( | |
| IN EHCI_QTD_HW *HwQtdPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Get Qtd alternate next pointer field | |
| Arguments: | |
| HwQtdPtr - A pointer to hardware Qtd structure | |
| Returns: | |
| A pointer to hardware alternate Qtd | |
| --*/ | |
| ; | |
| VOID | |
| ZeroOutQhOverlay ( | |
| IN EHCI_QH_ENTITY *QhPtr | |
| ) | |
| /*++ | |
| Routine Description: | |
| Zero out the fields in Qh structure | |
| Arguments: | |
| QhPtr - A pointer to Qh structure | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| VOID | |
| UpdateAsyncRequestTransfer ( | |
| IN EHCI_ASYNC_REQUEST *AsyncRequestPtr, | |
| IN UINT32 TransferResult, | |
| IN UINTN ErrTDPos | |
| ) | |
| /*++ | |
| Routine Description: | |
| Update asynchronous request transfer | |
| Arguments: | |
| AsyncRequestPtr - A pointer to async request | |
| TransferResult - transfer result | |
| ErrQtdPos - postion of error Qtd | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| DeleteAsyncRequestTransfer ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN UINT8 DeviceAddress, | |
| IN UINT8 EndPointAddress, | |
| OUT UINT8 *DataToggle | |
| ) | |
| /*++ | |
| Routine Description: | |
| Delete all asynchronous request transfer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| DeviceAddress - address of usb device | |
| EndPointAddress - address of endpoint | |
| DataToggle - stored data toggle | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| VOID | |
| CleanUpAllAsyncRequestTransfer ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Clean up all asynchronous request transfer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| VOID | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| ExecuteTransfer ( | |
| IN USB2_HC_DEV *HcDev, | |
| IN BOOLEAN IsControl, | |
| IN EHCI_QH_ENTITY *QhPtr, | |
| IN OUT UINTN *ActualLen, | |
| OUT UINT8 *DataToggle, | |
| IN UINTN TimeOut, | |
| OUT UINT32 *TransferResult | |
| ) | |
| /*++ | |
| Routine Description: | |
| Execute Bulk or SyncInterrupt Transfer | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| IsControl - Is control transfer or not | |
| QhPtr - A pointer to Qh | |
| ActualLen - Actual transfered Len | |
| DataToggle - Data Toggle | |
| TimeOut - TimeOut threshold | |
| TransferResult - Transfer result | |
| Returns: | |
| EFI_SUCCESS Sucess | |
| EFI_DEVICE_ERROR Error | |
| --*/ | |
| ; | |
| BOOLEAN | |
| CheckQtdsTransferResult ( | |
| IN BOOLEAN IsControl, | |
| IN EHCI_QH_ENTITY *QhPtr, | |
| OUT UINT32 *Result, | |
| OUT UINTN *ErrQtdPos, | |
| OUT UINTN *ActualLen | |
| ) | |
| /*++ | |
| Routine Description: | |
| Check transfer result of Qtds | |
| Arguments: | |
| IsControl - Is control transfer or not | |
| QhPtr - A pointer to Qh | |
| Result - Transfer result | |
| ErrQtdPos - Error TD Position | |
| ActualLen - Actual Transfer Size | |
| Returns: | |
| TRUE Qtds finished | |
| FALSE Not finish | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| AsyncRequestMoniter ( | |
| IN EFI_EVENT Event, | |
| IN VOID *Context | |
| ) | |
| /*++ | |
| Routine Description: | |
| Interrupt transfer periodic check handler | |
| Arguments: | |
| Event - Interrupt event | |
| Context - Pointer to USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| EFI_DEVICE_ERROR Fail | |
| --*/ | |
| ; | |
| EFI_STATUS | |
| CreateNULLQH ( | |
| IN USB2_HC_DEV *HcDev | |
| ) | |
| /*++ | |
| Routine Description: | |
| Create the NULL QH to make it as the Async QH header | |
| Arguments: | |
| HcDev - USB2_HC_DEV | |
| Returns: | |
| EFI_SUCCESS Success | |
| --*/ | |
| ; | |
| VOID | |
| DestroyNULLQH ( | |
| IN USB2_HC_DEV *HcDev | |
| ); | |
| VOID | |
| ClearLegacySupport ( | |
| IN USB2_HC_DEV *HcDev | |
| ); | |
| VOID | |
| HostReset ( | |
| IN USB2_HC_DEV *HcDev | |
| ); | |
| VOID | |
| DumpEHCIPortsStatus ( | |
| IN USB2_HC_DEV *HcDev | |
| ); | |
| #endif |