Uhci.c

Go to the documentation of this file.

 
#include "Uhci.h"
 
EFI_DRIVER_BINDING_PROTOCOL  gUhciDriverBinding = {
  UhciDriverBindingSupported,
  UhciDriverBindingStart,
  UhciDriverBindingStop,
  0x20,
  NULL,
  NULL
};
 
EFI_STATUS
EFIAPI
Uhci2Reset (
  IN EFI_USB2_HC_PROTOCOL  *This,
  IN UINT16                Attributes
  )
{
  USB_HC_DEV  *Uhc;
  EFI_TPL     OldTpl;
 
  if ((Attributes == EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG) ||
      (Attributes == EFI_USB_HC_RESET_HOST_WITH_DEBUG))
  {
    return EFI_UNSUPPORTED;
  }
 
  Uhc = UHC_FROM_USB2_HC_PROTO (This);
 
  if (Uhc->DevicePath != NULL) {
    //
    // Report Status Code to indicate reset happens
    //
    REPORT_STATUS_CODE_WITH_DEVICE_PATH (
      EFI_PROGRESS_CODE,
      (EFI_IO_BUS_USB | EFI_IOB_PC_RESET),
      Uhc->DevicePath
      );
  }
 
  OldTpl = gBS->RaiseTPL (UHCI_TPL);
 
  switch (Attributes) {
    case EFI_USB_HC_RESET_GLOBAL:
      //
      // Stop schedule and set the Global Reset bit in the command register
      //
      UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
      UhciSetRegBit (Uhc->PciIo, USBCMD_OFFSET, USBCMD_GRESET);
 
      gBS->Stall (UHC_ROOT_PORT_RESET_STALL);
 
      //
      // Clear the Global Reset bit to zero.
      //
      UhciClearRegBit (Uhc->PciIo, USBCMD_OFFSET, USBCMD_GRESET);
 
      gBS->Stall (UHC_ROOT_PORT_RECOVERY_STALL);
      break;
 
    case EFI_USB_HC_RESET_HOST_CONTROLLER:
      //
      // Stop schedule and set Host Controller Reset bit to 1
      //
      UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
      UhciSetRegBit (Uhc->PciIo, USBCMD_OFFSET, USBCMD_HCRESET);
 
      gBS->Stall (UHC_ROOT_PORT_RECOVERY_STALL);
      break;
 
    default:
      goto ON_INVAILD_PARAMETER;
  }
 
  //
  // Delete all old transactions on the USB bus, then
  // reinitialize the frame list
  //
  UhciFreeAllAsyncReq (Uhc);
  UhciDestoryFrameList (Uhc);
  UhciInitFrameList (Uhc);
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
 
ON_INVAILD_PARAMETER:
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_INVALID_PARAMETER;
}
 
EFI_STATUS
EFIAPI
Uhci2GetState (
  IN   EFI_USB2_HC_PROTOCOL  *This,
  OUT  EFI_USB_HC_STATE      *State
  )
{
  USB_HC_DEV  *Uhc;
  UINT16      UsbSts;
  UINT16      UsbCmd;
 
  if (State == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Uhc = UHC_FROM_USB2_HC_PROTO (This);
 
  UsbCmd = UhciReadReg (Uhc->PciIo, USBCMD_OFFSET);
  UsbSts = UhciReadReg (Uhc->PciIo, USBSTS_OFFSET);
 
  if ((UsbCmd & USBCMD_EGSM) != 0 ) {
    *State = EfiUsbHcStateSuspend;
  } else if ((UsbSts & USBSTS_HCH) != 0) {
    *State = EfiUsbHcStateHalt;
  } else {
    *State = EfiUsbHcStateOperational;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Uhci2SetState (
  IN EFI_USB2_HC_PROTOCOL  *This,
  IN EFI_USB_HC_STATE      State
  )
{
  EFI_USB_HC_STATE  CurState;
  USB_HC_DEV        *Uhc;
  EFI_TPL           OldTpl;
  EFI_STATUS        Status;
  UINT16            UsbCmd;
 
  Uhc    = UHC_FROM_USB2_HC_PROTO (This);
  Status = Uhci2GetState (This, &CurState);
 
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  if (CurState == State) {
    return EFI_SUCCESS;
  }
 
  Status = EFI_SUCCESS;
  OldTpl = gBS->RaiseTPL (UHCI_TPL);
 
  switch (State) {
    case EfiUsbHcStateHalt:
      Status = UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
      break;
 
    case EfiUsbHcStateOperational:
      UsbCmd = UhciReadReg (Uhc->PciIo, USBCMD_OFFSET);
 
      if (CurState == EfiUsbHcStateHalt) {
        //
        // Set Run/Stop bit to 1, also set the bandwidht reclamation
        // point to 64 bytes
        //
        UsbCmd |= USBCMD_RS | USBCMD_MAXP;
        UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, UsbCmd);
      } else if (CurState == EfiUsbHcStateSuspend) {
        //
        // If FGR(Force Global Resume) bit is 0, set it
        //
        if ((UsbCmd & USBCMD_FGR) == 0) {
          UsbCmd |= USBCMD_FGR;
          UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, UsbCmd);
        }
 
        //
        // wait 20ms to let resume complete (20ms is specified by UHCI spec)
        //
        gBS->Stall (UHC_FORCE_GLOBAL_RESUME_STALL);
 
        //
        // Write FGR bit to 0 and EGSM(Enter Global Suspend Mode) bit to 0
        //
        UsbCmd &= ~USBCMD_FGR;
        UsbCmd &= ~USBCMD_EGSM;
        UsbCmd |= USBCMD_RS;
        UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, UsbCmd);
      }
 
      break;
 
    case EfiUsbHcStateSuspend:
      Status = Uhci2SetState (This, EfiUsbHcStateHalt);
 
      if (EFI_ERROR (Status)) {
        Status = EFI_DEVICE_ERROR;
        goto ON_EXIT;
      }
 
      //
      // Set Enter Global Suspend Mode bit to 1.
      //
      UsbCmd  = UhciReadReg (Uhc->PciIo, USBCMD_OFFSET);
      UsbCmd |= USBCMD_EGSM;
      UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, UsbCmd);
      break;
 
    default:
      Status = EFI_INVALID_PARAMETER;
      break;
  }
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
Uhci2GetCapability (
  IN  EFI_USB2_HC_PROTOCOL  *This,
  OUT UINT8                 *MaxSpeed,
  OUT UINT8                 *PortNumber,
  OUT UINT8                 *Is64BitCapable
  )
{
  USB_HC_DEV  *Uhc;
  UINT32      Offset;
  UINT16      PortSC;
  UINT32      Index;
 
  Uhc = UHC_FROM_USB2_HC_PROTO (This);
 
  if ((NULL == MaxSpeed) || (NULL == PortNumber) || (NULL == Is64BitCapable)) {
    return EFI_INVALID_PARAMETER;
  }
 
  *MaxSpeed       = EFI_USB_SPEED_FULL;
  *Is64BitCapable = (UINT8)FALSE;
 
  *PortNumber = 0;
 
  for (Index = 0; Index < USB_MAX_ROOTHUB_PORT; Index++) {
    Offset = USBPORTSC_OFFSET + Index * 2;
    PortSC = UhciReadReg (Uhc->PciIo, Offset);
 
    //
    // Port status's bit 7 is reserved and always returns 1 if
    // the port number is valid. Intel's UHCI (in EHCI controller)
    // returns 0 in this bit if port number is invalid. Also, if
    // PciIo IoRead returns error, 0xFFFF is returned to caller.
    //
    if (((PortSC & 0x80) == 0) || (PortSC == 0xFFFF)) {
      break;
    }
 
    (*PortNumber)++;
  }
 
  Uhc->RootPorts = *PortNumber;
 
  DEBUG ((DEBUG_INFO, "Uhci2GetCapability: %d ports\n", (UINT32)Uhc->RootPorts));
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Uhci2GetRootHubPortStatus (
  IN   EFI_USB2_HC_PROTOCOL  *This,
  IN   UINT8                 PortNumber,
  OUT  EFI_USB_PORT_STATUS   *PortStatus
  )
{
  USB_HC_DEV  *Uhc;
  UINT32      Offset;
  UINT16      PortSC;
 
  Uhc = UHC_FROM_USB2_HC_PROTO (This);
 
  if (PortStatus == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (PortNumber >= Uhc->RootPorts) {
    return EFI_INVALID_PARAMETER;
  }
 
  Offset                       = USBPORTSC_OFFSET + PortNumber * 2;
  PortStatus->PortStatus       = 0;
  PortStatus->PortChangeStatus = 0;
 
  PortSC = UhciReadReg (Uhc->PciIo, Offset);
 
  if ((PortSC & USBPORTSC_CCS) != 0) {
    PortStatus->PortStatus |= USB_PORT_STAT_CONNECTION;
  }
 
  if ((PortSC & USBPORTSC_PED) != 0) {
    PortStatus->PortStatus |= USB_PORT_STAT_ENABLE;
  }
 
  if ((PortSC & USBPORTSC_SUSP) != 0) {
    DEBUG ((DEBUG_INFO, "Uhci2GetRootHubPortStatus: port %d is suspended\n", PortNumber));
    PortStatus->PortStatus |= USB_PORT_STAT_SUSPEND;
  }
 
  if ((PortSC & USBPORTSC_PR) != 0) {
    PortStatus->PortStatus |= USB_PORT_STAT_RESET;
  }
 
  if ((PortSC & USBPORTSC_LSDA) != 0) {
    PortStatus->PortStatus |= USB_PORT_STAT_LOW_SPEED;
  }
 
  //
  // CHC will always return one in port owner bit
  //
  PortStatus->PortStatus |= USB_PORT_STAT_OWNER;
 
  if ((PortSC & USBPORTSC_CSC) != 0) {
    PortStatus->PortChangeStatus |= USB_PORT_STAT_C_CONNECTION;
  }
 
  if ((PortSC & USBPORTSC_PEDC) != 0) {
    PortStatus->PortChangeStatus |= USB_PORT_STAT_C_ENABLE;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Uhci2SetRootHubPortFeature (
  IN EFI_USB2_HC_PROTOCOL  *This,
  IN UINT8                 PortNumber,
  IN EFI_USB_PORT_FEATURE  PortFeature
  )
{
  USB_HC_DEV  *Uhc;
  EFI_TPL     OldTpl;
  UINT32      Offset;
  UINT16      PortSC;
  UINT16      Command;
 
  Uhc = UHC_FROM_USB2_HC_PROTO (This);
 
  if (PortNumber >= Uhc->RootPorts) {
    return EFI_INVALID_PARAMETER;
  }
 
  Offset = USBPORTSC_OFFSET + PortNumber * 2;
 
  OldTpl = gBS->RaiseTPL (UHCI_TPL);
  PortSC = UhciReadReg (Uhc->PciIo, Offset);
 
  switch (PortFeature) {
    case EfiUsbPortSuspend:
      Command = UhciReadReg (Uhc->PciIo, USBCMD_OFFSET);
      if ((Command & USBCMD_EGSM) == 0) {
        //
        // if global suspend is not active, can set port suspend
        //
        PortSC &= 0xfff5;
        PortSC |= USBPORTSC_SUSP;
      }
 
      break;
 
    case EfiUsbPortReset:
      PortSC &= 0xfff5;
      PortSC |= USBPORTSC_PR;
      break;
 
    case EfiUsbPortPower:
      //
      // No action
      //
      break;
 
    case EfiUsbPortEnable:
      PortSC &= 0xfff5;
      PortSC |= USBPORTSC_PED;
      break;
 
    default:
      gBS->RestoreTPL (OldTpl);
      return EFI_INVALID_PARAMETER;
  }
 
  UhciWriteReg (Uhc->PciIo, Offset, PortSC);
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Uhci2ClearRootHubPortFeature (
  IN EFI_USB2_HC_PROTOCOL  *This,
  IN UINT8                 PortNumber,
  IN EFI_USB_PORT_FEATURE  PortFeature
  )
{
  USB_HC_DEV  *Uhc;
  EFI_TPL     OldTpl;
  UINT32      Offset;
  UINT16      PortSC;
 
  Uhc = UHC_FROM_USB2_HC_PROTO (This);
 
  if (PortNumber >= Uhc->RootPorts) {
    return EFI_INVALID_PARAMETER;
  }
 
  Offset = USBPORTSC_OFFSET + PortNumber * 2;
 
  OldTpl = gBS->RaiseTPL (UHCI_TPL);
  PortSC = UhciReadReg (Uhc->PciIo, Offset);
 
  switch (PortFeature) {
    case EfiUsbPortEnable:
      PortSC &= 0xfff5;
      PortSC &= ~USBPORTSC_PED;
      break;
 
    case EfiUsbPortSuspend:
      //
      // Cause a resume on the specified port if in suspend mode.
      //
      PortSC &= 0xfff5;
      PortSC &= ~USBPORTSC_SUSP;
      break;
 
    case EfiUsbPortPower:
      //
      // No action
      //
      break;
 
    case EfiUsbPortReset:
      PortSC &= 0xfff5;
      PortSC &= ~USBPORTSC_PR;
      break;
 
    case EfiUsbPortConnectChange:
      PortSC &= 0xfff5;
      PortSC |= USBPORTSC_CSC;
      break;
 
    case EfiUsbPortEnableChange:
      PortSC &= 0xfff5;
      PortSC |= USBPORTSC_PEDC;
      break;
 
    case EfiUsbPortSuspendChange:
      //
      // Root hub does not support this
      //
      break;
 
    case EfiUsbPortOverCurrentChange:
      //
      // Root hub does not support this
      //
      break;
 
    case EfiUsbPortResetChange:
      //
      // Root hub does not support this
      //
      break;
 
    default:
      gBS->RestoreTPL (OldTpl);
      return EFI_INVALID_PARAMETER;
  }
 
  UhciWriteReg (Uhc->PciIo, Offset, PortSC);
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Uhci2ControlTransfer (
  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
  )
{
  USB_HC_DEV      *Uhc;
  UHCI_TD_SW      *TDs;
  EFI_TPL         OldTpl;
  EFI_STATUS      Status;
  UHCI_QH_RESULT  QhResult;
  UINT8           PktId;
  UINT8           *RequestPhy;
  VOID            *RequestMap;
  UINT8           *DataPhy;
  VOID            *DataMap;
  BOOLEAN         IsSlowDevice;
  UINTN           TransferDataLength;
 
  Uhc        = UHC_FROM_USB2_HC_PROTO (This);
  TDs        = NULL;
  DataPhy    = NULL;
  DataMap    = NULL;
  RequestPhy = NULL;
  RequestMap = NULL;
 
  IsSlowDevice = (BOOLEAN)((EFI_USB_SPEED_LOW == DeviceSpeed) ? TRUE : FALSE);
 
  //
  // Parameters Checking
  //
  if ((Request == NULL) || (TransferResult == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (IsSlowDevice && (MaximumPacketLength != 8)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((MaximumPacketLength != 8) &&  (MaximumPacketLength != 16) &&
      (MaximumPacketLength != 32) && (MaximumPacketLength != 64))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((TransferDirection != EfiUsbNoData) && ((Data == NULL) || (DataLength == NULL))) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (TransferDirection == EfiUsbNoData) {
    TransferDataLength = 0;
  } else {
    TransferDataLength = *DataLength;
  }
 
  *TransferResult = EFI_USB_ERR_SYSTEM;
  Status          = EFI_DEVICE_ERROR;
 
  //
  // If errors exist that cause host controller halt,
  // clear status then return EFI_DEVICE_ERROR.
  //
  UhciAckAllInterrupt (Uhc);
 
  if (!UhciIsHcWorking (Uhc->PciIo)) {
    return EFI_DEVICE_ERROR;
  }
 
  OldTpl = gBS->RaiseTPL (UHCI_TPL);
 
  //
  // Map the Request and data for bus master access,
  // then create a list of TD for this transfer
  //
  Status = UhciMapUserRequest (Uhc, Request, &RequestPhy, &RequestMap);
 
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  Status = UhciMapUserData (Uhc, TransferDirection, Data, DataLength, &PktId, &DataPhy, &DataMap);
 
  if (EFI_ERROR (Status)) {
    Uhc->PciIo->Unmap (Uhc->PciIo, RequestMap);
    goto ON_EXIT;
  }
 
  TDs = UhciCreateCtrlTds (
          Uhc,
          DeviceAddress,
          PktId,
          (UINT8 *)Request,
          RequestPhy,
          (UINT8 *)Data,
          DataPhy,
          TransferDataLength,
          (UINT8)MaximumPacketLength,
          IsSlowDevice
          );
 
  if (TDs == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto UNMAP_DATA;
  }
 
  //
  // According to the speed of the end point, link
  // the TD to corrosponding queue head, then check
  // the execution result
  //
  UhciLinkTdToQh (Uhc, Uhc->CtrlQh, TDs);
  Status = UhciExecuteTransfer (Uhc, Uhc->CtrlQh, TDs, TimeOut, IsSlowDevice, &QhResult);
  UhciUnlinkTdFromQh (Uhc->CtrlQh, TDs);
 
  Uhc->PciIo->Flush (Uhc->PciIo);
 
  if (!EFI_ERROR (Status)) {
    *TransferResult = QhResult.Result;
 
    if (DataLength != NULL) {
      *DataLength = QhResult.Complete;
    }
  }
 
  UhciDestoryTds (Uhc, TDs);
 
UNMAP_DATA:
  Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
  Uhc->PciIo->Unmap (Uhc->PciIo, RequestMap);
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
Uhci2BulkTransfer (
  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_USB_DATA_DIRECTION  Direction;
  EFI_TPL                 OldTpl;
  USB_HC_DEV              *Uhc;
  UHCI_TD_SW              *TDs;
  UHCI_QH_SW              *BulkQh;
  UHCI_QH_RESULT          QhResult;
  EFI_STATUS              Status;
  UINT8                   PktId;
  UINT8                   *DataPhy;
  VOID                    *DataMap;
 
  Uhc     = UHC_FROM_USB2_HC_PROTO (This);
  DataPhy = NULL;
  DataMap = NULL;
 
  if (DeviceSpeed == EFI_USB_SPEED_LOW) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((DataLength == NULL) || (*DataLength == 0) || (Data == NULL) || (TransferResult == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((*DataToggle != 1) && (*DataToggle != 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((MaximumPacketLength != 8) && (MaximumPacketLength != 16) &&
      (MaximumPacketLength != 32) && (MaximumPacketLength != 64))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  *TransferResult = EFI_USB_ERR_SYSTEM;
  Status          = EFI_OUT_OF_RESOURCES;
 
  //
  // If has errors that cause host controller halt,
  // then return EFI_DEVICE_ERROR directly.
  //
  UhciAckAllInterrupt (Uhc);
 
  if (!UhciIsHcWorking (Uhc->PciIo)) {
    return EFI_DEVICE_ERROR;
  }
 
  OldTpl = gBS->RaiseTPL (UHCI_TPL);
 
  //
  // Map the source data buffer for bus master access,
  // then create a list of TDs
  //
  if ((EndPointAddress & 0x80) != 0) {
    Direction = EfiUsbDataIn;
  } else {
    Direction = EfiUsbDataOut;
  }
 
  Status = UhciMapUserData (Uhc, Direction, *Data, DataLength, &PktId, &DataPhy, &DataMap);
 
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  Status = EFI_OUT_OF_RESOURCES;
  TDs    = UhciCreateBulkOrIntTds (
             Uhc,
             DeviceAddress,
             EndPointAddress,
             PktId,
             (UINT8 *)*Data,
             DataPhy,
             *DataLength,
             DataToggle,
             (UINT8)MaximumPacketLength,
             FALSE
             );
 
  if (TDs == NULL) {
    Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
    goto ON_EXIT;
  }
 
  //
  // Link the TDs to bulk queue head. According to the platfore
  // defintion of UHCI_NO_BW_RECLAMATION, BulkQh is either configured
  // to do full speed bandwidth reclamation or not.
  //
  BulkQh = Uhc->BulkQh;
 
  UhciLinkTdToQh (Uhc, BulkQh, TDs);
  Status = UhciExecuteTransfer (Uhc, BulkQh, TDs, TimeOut, FALSE, &QhResult);
  UhciUnlinkTdFromQh (BulkQh, TDs);
 
  Uhc->PciIo->Flush (Uhc->PciIo);
 
  if (!EFI_ERROR (Status)) {
    *TransferResult = QhResult.Result;
    *DataToggle     = QhResult.NextToggle;
    *DataLength     = QhResult.Complete;
  }
 
  UhciDestoryTds (Uhc, TDs);
  Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
Uhci2AsyncInterruptTransfer (
  IN     EFI_USB2_HC_PROTOCOL                *This,
  IN     UINT8                               DeviceAddress,
  IN     UINT8                               EndPointAddress,
  IN     UINT8                               DeviceSpeed,
  IN     UINTN                               MaximumPacketLength,
  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
  )
{
  USB_HC_DEV  *Uhc;
  BOOLEAN     IsSlowDevice;
  UHCI_QH_SW  *Qh;
  UHCI_TD_SW  *IntTds;
  EFI_TPL     OldTpl;
  EFI_STATUS  Status;
  UINT8       *DataPtr;
  UINT8       *DataPhy;
  UINT8       PktId;
 
  Uhc     = UHC_FROM_USB2_HC_PROTO (This);
  Qh      = NULL;
  IntTds  = NULL;
  DataPtr = NULL;
  DataPhy = NULL;
 
  IsSlowDevice = (BOOLEAN)((EFI_USB_SPEED_LOW == DeviceSpeed) ? TRUE : FALSE);
 
  if ((EndPointAddress & 0x80) == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Delete Async interrupt transfer request
  //
  if (!IsNewTransfer) {
    OldTpl = gBS->RaiseTPL (UHCI_TPL);
    Status = UhciRemoveAsyncReq (Uhc, DeviceAddress, EndPointAddress, DataToggle);
 
    gBS->RestoreTPL (OldTpl);
    return Status;
  }
 
  if ((PollingInterval < 1) || (PollingInterval > 255)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataLength == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((*DataToggle != 1) && (*DataToggle != 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // If has errors that cause host controller halt,
  // then return EFI_DEVICE_ERROR directly.
  //
  UhciAckAllInterrupt (Uhc);
 
  if (!UhciIsHcWorking (Uhc->PciIo)) {
    return EFI_DEVICE_ERROR;
  }
 
  if ((EndPointAddress & 0x80) == 0) {
    PktId = OUTPUT_PACKET_ID;
  } else {
    PktId = INPUT_PACKET_ID;
  }
 
  //
  // Allocate and map source data buffer for bus master access.
  //
  DataPtr = UsbHcAllocateMem (Uhc->MemPool, DataLength);
 
  if (DataPtr == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  DataPhy = (UINT8 *)(UINTN)UsbHcGetPciAddressForHostMem (Uhc->MemPool, DataPtr, DataLength);
 
  OldTpl = gBS->RaiseTPL (UHCI_TPL);
 
  Qh = UhciCreateQh (Uhc, PollingInterval);
 
  if (Qh == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto FREE_DATA;
  }
 
  IntTds = UhciCreateBulkOrIntTds (
             Uhc,
             DeviceAddress,
             EndPointAddress,
             PktId,
             DataPtr,
             DataPhy,
             DataLength,
             DataToggle,
             (UINT8)MaximumPacketLength,
             IsSlowDevice
             );
 
  if (IntTds == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto DESTORY_QH;
  }
 
  UhciLinkTdToQh (Uhc, Qh, IntTds);
 
  //
  // Save QH-TD structures to async Interrupt transfer list,
  // for monitor interrupt transfer execution routine use.
  //
  Status = UhciCreateAsyncReq (
             Uhc,
             Qh,
             IntTds,
             DeviceAddress,
             EndPointAddress,
             DataLength,
             PollingInterval,
             DataPtr,
             CallBackFunction,
             Context,
             IsSlowDevice
             );
 
  if (EFI_ERROR (Status)) {
    goto DESTORY_QH;
  }
 
  UhciLinkQhToFrameList (Uhc, Qh);
 
  gBS->RestoreTPL (OldTpl);
  return EFI_SUCCESS;
 
DESTORY_QH:
  UsbHcFreeMem (Uhc->MemPool, Qh, sizeof (UHCI_QH_SW));
 
FREE_DATA:
  UsbHcFreeMem (Uhc->MemPool, DataPtr, DataLength);
  Uhc->PciIo->Flush (Uhc->PciIo);
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
Uhci2SyncInterruptTransfer (
  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      Status;
  USB_HC_DEV      *Uhc;
  UHCI_TD_SW      *TDs;
  UHCI_QH_RESULT  QhResult;
  EFI_TPL         OldTpl;
  UINT8           *DataPhy;
  VOID            *DataMap;
  UINT8           PktId;
  BOOLEAN         IsSlowDevice;
 
  Uhc     = UHC_FROM_USB2_HC_PROTO (This);
  DataPhy = NULL;
  DataMap = NULL;
  TDs     = NULL;
 
  if (DeviceSpeed == EFI_USB_SPEED_HIGH) {
    return EFI_INVALID_PARAMETER;
  }
 
  IsSlowDevice = (BOOLEAN)((EFI_USB_SPEED_LOW == DeviceSpeed) ? TRUE : FALSE);
 
  if ((DataLength == NULL) || (Data == NULL) || (TransferResult == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((*DataToggle != 1) && (*DataToggle != 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((*DataLength == 0) || (MaximumPacketLength > 64)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (IsSlowDevice && (MaximumPacketLength > 8)) {
    return EFI_INVALID_PARAMETER;
  }
 
  *TransferResult = EFI_USB_ERR_SYSTEM;
  Status          = EFI_DEVICE_ERROR;
 
  UhciAckAllInterrupt (Uhc);
 
  if (!UhciIsHcWorking (Uhc->PciIo)) {
    return Status;
  }
 
  OldTpl = gBS->RaiseTPL (UHCI_TPL);
 
  //
  // Map the source data buffer for bus master access.
  // Create Tds list, then link it to the UHC's interrupt list
  //
  Status = UhciMapUserData (
             Uhc,
             EfiUsbDataIn,
             Data,
             DataLength,
             &PktId,
             &DataPhy,
             &DataMap
             );
 
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  TDs = UhciCreateBulkOrIntTds (
          Uhc,
          DeviceAddress,
          EndPointAddress,
          PktId,
          (UINT8 *)Data,
          DataPhy,
          *DataLength,
          DataToggle,
          (UINT8)MaximumPacketLength,
          IsSlowDevice
          );
 
  if (TDs == NULL) {
    Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
 
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_EXIT;
  }
 
  UhciLinkTdToQh (Uhc, Uhc->SyncIntQh, TDs);
 
  Status = UhciExecuteTransfer (Uhc, Uhc->SyncIntQh, TDs, TimeOut, IsSlowDevice, &QhResult);
 
  UhciUnlinkTdFromQh (Uhc->SyncIntQh, TDs);
  Uhc->PciIo->Flush (Uhc->PciIo);
 
  if (!EFI_ERROR (Status)) {
    *TransferResult = QhResult.Result;
    *DataToggle     = QhResult.NextToggle;
    *DataLength     = QhResult.Complete;
  }
 
  UhciDestoryTds (Uhc, TDs);
  Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
Uhci2IsochronousTransfer (
  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
  )
{
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
Uhci2AsyncIsochronousTransfer (
  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
  )
{
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
UhciDriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  return EfiLibInstallDriverBindingComponentName2 (
           ImageHandle,
           SystemTable,
           &gUhciDriverBinding,
           ImageHandle,
           &gUhciComponentName,
           &gUhciComponentName2
           );
}
 
EFI_STATUS
EFIAPI
UhciDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  EFI_STATUS           OpenStatus;
  EFI_STATUS           Status;
  EFI_PCI_IO_PROTOCOL  *PciIo;
  USB_CLASSC           UsbClassCReg;
 
  //
  // Test whether there is PCI IO Protocol attached on the controller handle.
  //
  OpenStatus = gBS->OpenProtocol (
                      Controller,
                      &gEfiPciIoProtocolGuid,
                      (VOID **)&PciIo,
                      This->DriverBindingHandle,
                      Controller,
                      EFI_OPEN_PROTOCOL_BY_DRIVER
                      );
 
  if (EFI_ERROR (OpenStatus)) {
    return OpenStatus;
  }
 
  Status = PciIo->Pci.Read (
                        PciIo,
                        EfiPciIoWidthUint8,
                        PCI_CLASSCODE_OFFSET,
                        sizeof (USB_CLASSC) / sizeof (UINT8),
                        &UsbClassCReg
                        );
 
  if (EFI_ERROR (Status)) {
    Status = EFI_UNSUPPORTED;
    goto ON_EXIT;
  }
 
  //
  // Test whether the controller belongs to UHCI type
  //
  if ((UsbClassCReg.BaseCode != PCI_CLASS_SERIAL) ||
      (UsbClassCReg.SubClassCode != PCI_CLASS_SERIAL_USB) ||
      (UsbClassCReg.ProgInterface != PCI_IF_UHCI)
      )
  {
    Status = EFI_UNSUPPORTED;
  }
 
ON_EXIT:
  gBS->CloseProtocol (
         Controller,
         &gEfiPciIoProtocolGuid,
         This->DriverBindingHandle,
         Controller
         );
 
  return Status;
}
 
USB_HC_DEV *
UhciAllocateDev (
  IN EFI_PCI_IO_PROTOCOL       *PciIo,
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
  IN UINT64                    OriginalPciAttributes
  )
{
  USB_HC_DEV  *Uhc;
  EFI_STATUS  Status;
 
  Uhc = AllocateZeroPool (sizeof (USB_HC_DEV));
 
  if (Uhc == NULL) {
    return NULL;
  }
 
  //
  // This driver supports both USB_HC_PROTOCOL and USB2_HC_PROTOCOL.
  // USB_HC_PROTOCOL is for EFI 1.1 backward compability.
  //
  Uhc->Signature                       = USB_HC_DEV_SIGNATURE;
  Uhc->Usb2Hc.GetCapability            = Uhci2GetCapability;
  Uhc->Usb2Hc.Reset                    = Uhci2Reset;
  Uhc->Usb2Hc.GetState                 = Uhci2GetState;
  Uhc->Usb2Hc.SetState                 = Uhci2SetState;
  Uhc->Usb2Hc.ControlTransfer          = Uhci2ControlTransfer;
  Uhc->Usb2Hc.BulkTransfer             = Uhci2BulkTransfer;
  Uhc->Usb2Hc.AsyncInterruptTransfer   = Uhci2AsyncInterruptTransfer;
  Uhc->Usb2Hc.SyncInterruptTransfer    = Uhci2SyncInterruptTransfer;
  Uhc->Usb2Hc.IsochronousTransfer      = Uhci2IsochronousTransfer;
  Uhc->Usb2Hc.AsyncIsochronousTransfer = Uhci2AsyncIsochronousTransfer;
  Uhc->Usb2Hc.GetRootHubPortStatus     = Uhci2GetRootHubPortStatus;
  Uhc->Usb2Hc.SetRootHubPortFeature    = Uhci2SetRootHubPortFeature;
  Uhc->Usb2Hc.ClearRootHubPortFeature  = Uhci2ClearRootHubPortFeature;
  Uhc->Usb2Hc.MajorRevision            = 0x1;
  Uhc->Usb2Hc.MinorRevision            = 0x1;
 
  Uhc->PciIo                 = PciIo;
  Uhc->DevicePath            = DevicePath;
  Uhc->OriginalPciAttributes = OriginalPciAttributes;
  Uhc->MemPool               = UsbHcInitMemPool (PciIo, TRUE, 0);
 
  if (Uhc->MemPool == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_ERROR;
  }
 
  InitializeListHead (&Uhc->AsyncIntList);
 
  Status = gBS->CreateEvent (
                  EVT_TIMER | EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  UhciMonitorAsyncReqList,
                  Uhc,
                  &Uhc->AsyncIntMonitor
                  );
 
  if (EFI_ERROR (Status)) {
    UsbHcFreeMemPool (Uhc->MemPool);
    goto ON_ERROR;
  }
 
  return Uhc;
 
ON_ERROR:
  FreePool (Uhc);
  return NULL;
}
 
VOID
UhciFreeDev (
  IN USB_HC_DEV  *Uhc
  )
{
  if (Uhc->AsyncIntMonitor != NULL) {
    gBS->CloseEvent (Uhc->AsyncIntMonitor);
  }
 
  if (Uhc->ExitBootServiceEvent != NULL) {
    gBS->CloseEvent (Uhc->ExitBootServiceEvent);
  }
 
  if (Uhc->MemPool != NULL) {
    UsbHcFreeMemPool (Uhc->MemPool);
  }
 
  if (Uhc->CtrlNameTable != NULL) {
    FreeUnicodeStringTable (Uhc->CtrlNameTable);
  }
 
  FreePool (Uhc);
}
 
VOID
UhciCleanDevUp (
  IN  EFI_HANDLE            Controller,
  IN  EFI_USB2_HC_PROTOCOL  *This
  )
{
  USB_HC_DEV  *Uhc;
  EFI_STATUS  Status;
 
  //
  // Uninstall the USB_HC and USB_HC2 protocol, then disable the controller
  //
  Uhc = UHC_FROM_USB2_HC_PROTO (This);
 
  Status = gBS->UninstallProtocolInterface (
                  Controller,
                  &gEfiUsb2HcProtocolGuid,
                  &Uhc->Usb2Hc
                  );
  if (EFI_ERROR (Status)) {
    return;
  }
 
  UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
  UhciFreeAllAsyncReq (Uhc);
  UhciDestoryFrameList (Uhc);
 
  //
  // Restore original PCI attributes
  //
  Uhc->PciIo->Attributes (
                Uhc->PciIo,
                EfiPciIoAttributeOperationSet,
                Uhc->OriginalPciAttributes,
                NULL
                );
 
  UhciFreeDev (Uhc);
}
 
VOID
EFIAPI
UhcExitBootService (
  EFI_EVENT  Event,
  VOID       *Context
  )
{
  USB_HC_DEV  *Uhc;
 
  Uhc = (USB_HC_DEV *)Context;
 
  //
  // Stop the Host Controller
  //
  UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
 
  //
  // Reset the Host Controller
  //
  UhciSetRegBit (Uhc->PciIo, USBCMD_OFFSET, USBCMD_HCRESET);
  gBS->Stall (UHC_ROOT_PORT_RECOVERY_STALL);
}
 
EFI_STATUS
EFIAPI
UhciDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  EFI_STATUS                Status;
  EFI_PCI_IO_PROTOCOL       *PciIo;
  USB_HC_DEV                *Uhc;
  UINT64                    Supports;
  UINT64                    OriginalPciAttributes;
  BOOLEAN                   PciAttributesSaved;
  EFI_DEVICE_PATH_PROTOCOL  *HcDevicePath;
 
  //
  // Open PCIIO, then enable the EHC device and turn off emulation
  //
  Uhc    = NULL;
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiPciIoProtocolGuid,
                  (VOID **)&PciIo,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Open Device Path Protocol for on USB host controller
  //
  HcDevicePath = NULL;
  Status       = gBS->OpenProtocol (
                        Controller,
                        &gEfiDevicePathProtocolGuid,
                        (VOID **)&HcDevicePath,
                        This->DriverBindingHandle,
                        Controller,
                        EFI_OPEN_PROTOCOL_GET_PROTOCOL
                        );
 
  PciAttributesSaved = FALSE;
  //
  // Save original PCI attributes
  //
  Status = PciIo->Attributes (
                    PciIo,
                    EfiPciIoAttributeOperationGet,
                    0,
                    &OriginalPciAttributes
                    );
 
  if (EFI_ERROR (Status)) {
    goto CLOSE_PCIIO;
  }
 
  PciAttributesSaved = TRUE;
 
  //
  // Robustnesss improvement such as for UoL
  // Default is not required.
  //
  if (FeaturePcdGet (PcdTurnOffUsbLegacySupport)) {
    UhciTurnOffUsbEmulation (PciIo);
  }
 
  Status = PciIo->Attributes (
                    PciIo,
                    EfiPciIoAttributeOperationSupported,
                    0,
                    &Supports
                    );
  if (!EFI_ERROR (Status)) {
    Supports &= (UINT64)EFI_PCI_DEVICE_ENABLE;
    Status    = PciIo->Attributes (
                         PciIo,
                         EfiPciIoAttributeOperationEnable,
                         Supports,
                         NULL
                         );
  }
 
  if (EFI_ERROR (Status)) {
    goto CLOSE_PCIIO;
  }
 
  Uhc = UhciAllocateDev (PciIo, HcDevicePath, OriginalPciAttributes);
 
  if (Uhc == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto CLOSE_PCIIO;
  }
 
  //
  // Allocate and Init Host Controller's Frame List Entry
  //
  Status = UhciInitFrameList (Uhc);
 
  if (EFI_ERROR (Status)) {
    Status = EFI_OUT_OF_RESOURCES;
    goto FREE_UHC;
  }
 
  Status = gBS->SetTimer (
                  Uhc->AsyncIntMonitor,
                  TimerPeriodic,
                  UHC_ASYNC_POLL_INTERVAL
                  );
 
  if (EFI_ERROR (Status)) {
    goto FREE_UHC;
  }
 
  //
  // Install USB2_HC_PROTOCOL
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Controller,
                  &gEfiUsb2HcProtocolGuid,
                  &Uhc->Usb2Hc,
                  NULL
                  );
 
  if (EFI_ERROR (Status)) {
    goto FREE_UHC;
  }
 
  //
  // Create event to stop the HC when exit boot service.
  //
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  UhcExitBootService,
                  Uhc,
                  &gEfiEventExitBootServicesGuid,
                  &Uhc->ExitBootServiceEvent
                  );
  if (EFI_ERROR (Status)) {
    goto UNINSTALL_USBHC;
  }
 
  //
  // Install the component name protocol
  //
  Uhc->CtrlNameTable = NULL;
 
  AddUnicodeString2 (
    "eng",
    gUhciComponentName.SupportedLanguages,
    &Uhc->CtrlNameTable,
    L"Usb Universal Host Controller",
    TRUE
    );
  AddUnicodeString2 (
    "en",
    gUhciComponentName2.SupportedLanguages,
    &Uhc->CtrlNameTable,
    L"Usb Universal Host Controller",
    FALSE
    );
 
  //
  // Start the UHCI hardware, also set its reclamation point to 64 bytes
  //
  UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, USBCMD_RS | USBCMD_MAXP);
 
  return EFI_SUCCESS;
 
UNINSTALL_USBHC:
  gBS->UninstallMultipleProtocolInterfaces (
         Controller,
         &gEfiUsb2HcProtocolGuid,
         &Uhc->Usb2Hc,
         NULL
         );
 
FREE_UHC:
  UhciFreeDev (Uhc);
 
CLOSE_PCIIO:
  if (PciAttributesSaved) {
    //
    // Restore original PCI attributes
    //
    PciIo->Attributes (
             PciIo,
             EfiPciIoAttributeOperationSet,
             OriginalPciAttributes,
             NULL
             );
  }
 
  gBS->CloseProtocol (
         Controller,
         &gEfiPciIoProtocolGuid,
         This->DriverBindingHandle,
         Controller
         );
 
  return Status;
}
 
EFI_STATUS
EFIAPI
UhciDriverBindingStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer
  )
{
  EFI_USB2_HC_PROTOCOL  *Usb2Hc;
  EFI_STATUS            Status;
 
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiUsb2HcProtocolGuid,
                  (VOID **)&Usb2Hc,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  //
  // Test whether the Controller handler passed in is a valid
  // Usb controller handle that should be supported, if not,
  // return the error status directly
  //
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  UhciCleanDevUp (Controller, Usb2Hc);
 
  gBS->CloseProtocol (
         Controller,
         &gEfiPciIoProtocolGuid,
         This->DriverBindingHandle,
         Controller
         );
 
  return EFI_SUCCESS;
}