tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/EdkModulePkg/Bus/Pci/Ehci/Dxe/Ehci.h

2919 lines
54 KiB
C
Raw Blame History

/*++
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
Reference in New Issue View Git Blame Copy Permalink