path: root/EdkModulePkg/Bus/Pci/Ehci/Dxe/Ehci.h

/*++

Copyright (c) 2006, 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>


GLOBAL_REMOVE_IF_UNREFERENCED    extern UINTN  gEHCDebugLevel;
GLOBAL_REMOVE_IF_UNREFERENCED    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 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 1

#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                 1
#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 UINT32                       mUsbCapabilityLen;
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      0x20

#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;

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  ExtBufferPointer0;
  UINT32  ExtBufferPointer1;
  UINT32  ExtBufferPointer2;
  UINT32  ExtBufferPointer3;
  UINT32  ExtBufferPointer4;
} EHCI_QTD_HW;

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  ExtBufferPointer0;
  UINT32  ExtBufferPointer1;
  UINT32  ExtBufferPointer2;
  UINT32  ExtBufferPointer3;
  UINT32  ExtBufferPointer4;
} 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;

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;
};

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;
} USB2_HC_DEV;


//
// 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
GetNumberOfTransaction (
  IN UINTN    SizeOfData,
  IN UINTN    SizeOfTransaction
  )
/*++

Routine Description:

  Number of Transactions in one Qtd
  
Arguments:

  SizeOfData           - Size of one Qtd
  SizeOfTransaction    - Size of one Transaction
   
Returns:

  Number of Transactions in this Qtd

--*/
;

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
    
--*/
;

#endif