MdeModulePkg: Apply uncrustify changes

[mirror_edk2.git] / MdeModulePkg / Bus / Pci / XhciDxe / Xhci.c

/** @file\r
  The XHCI controller driver.\r
\r
Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "Xhci.h"\r
\r
//\r
// Two arrays used to translate the XHCI port state (change)\r
// to the UEFI protocol's port state (change).\r
//\r
USB_PORT_STATE_MAP  mUsbPortStateMap[] = {\r
  { XHC_PORTSC_CCS,   USB_PORT_STAT_CONNECTION  },\r
  { XHC_PORTSC_PED,   USB_PORT_STAT_ENABLE      },\r
  { XHC_PORTSC_OCA,   USB_PORT_STAT_OVERCURRENT },\r
  { XHC_PORTSC_RESET, USB_PORT_STAT_RESET       }\r
};\r
\r
USB_PORT_STATE_MAP  mUsbPortChangeMap[] = {\r
  { XHC_PORTSC_CSC, USB_PORT_STAT_C_CONNECTION  },\r
  { XHC_PORTSC_PEC, USB_PORT_STAT_C_ENABLE      },\r
  { XHC_PORTSC_OCC, USB_PORT_STAT_C_OVERCURRENT },\r
  { XHC_PORTSC_PRC, USB_PORT_STAT_C_RESET       }\r
};\r
\r
USB_CLEAR_PORT_MAP  mUsbClearPortChangeMap[] = {\r
  { XHC_PORTSC_CSC, EfiUsbPortConnectChange     },\r
  { XHC_PORTSC_PEC, EfiUsbPortEnableChange      },\r
  { XHC_PORTSC_OCC, EfiUsbPortOverCurrentChange },\r
  { XHC_PORTSC_PRC, EfiUsbPortResetChange       }\r
};\r
\r
USB_PORT_STATE_MAP  mUsbHubPortStateMap[] = {\r
  { XHC_HUB_PORTSC_CCS,   USB_PORT_STAT_CONNECTION  },\r
  { XHC_HUB_PORTSC_PED,   USB_PORT_STAT_ENABLE      },\r
  { XHC_HUB_PORTSC_OCA,   USB_PORT_STAT_OVERCURRENT },\r
  { XHC_HUB_PORTSC_RESET, USB_PORT_STAT_RESET       }\r
};\r
\r
USB_PORT_STATE_MAP  mUsbHubPortChangeMap[] = {\r
  { XHC_HUB_PORTSC_CSC, USB_PORT_STAT_C_CONNECTION  },\r
  { XHC_HUB_PORTSC_PEC, USB_PORT_STAT_C_ENABLE      },\r
  { XHC_HUB_PORTSC_OCC, USB_PORT_STAT_C_OVERCURRENT },\r
  { XHC_HUB_PORTSC_PRC, USB_PORT_STAT_C_RESET       }\r
};\r
\r
USB_CLEAR_PORT_MAP  mUsbHubClearPortChangeMap[] = {\r
  { XHC_HUB_PORTSC_CSC,  EfiUsbPortConnectChange     },\r
  { XHC_HUB_PORTSC_PEC,  EfiUsbPortEnableChange      },\r
  { XHC_HUB_PORTSC_OCC,  EfiUsbPortOverCurrentChange },\r
  { XHC_HUB_PORTSC_PRC,  EfiUsbPortResetChange       },\r
  { XHC_HUB_PORTSC_BHRC, Usb3PortBHPortResetChange   }\r
};\r
\r
EFI_DRIVER_BINDING_PROTOCOL  gXhciDriverBinding = {\r
  XhcDriverBindingSupported,\r
  XhcDriverBindingStart,\r
  XhcDriverBindingStop,\r
  0x30,\r
  NULL,\r
  NULL\r
};\r
\r
//\r
// Template for Xhci's Usb2 Host Controller Protocol Instance.\r
//\r
EFI_USB2_HC_PROTOCOL  gXhciUsb2HcTemplate = {\r
  XhcGetCapability,\r
  XhcReset,\r
  XhcGetState,\r
  XhcSetState,\r
  XhcControlTransfer,\r
  XhcBulkTransfer,\r
  XhcAsyncInterruptTransfer,\r
  XhcSyncInterruptTransfer,\r
  XhcIsochronousTransfer,\r
  XhcAsyncIsochronousTransfer,\r
  XhcGetRootHubPortStatus,\r
  XhcSetRootHubPortFeature,\r
  XhcClearRootHubPortFeature,\r
  0x3,\r
  0x0\r
};\r
\r
/**\r
  Retrieves the capability of root hub ports.\r
\r
  @param  This                  The EFI_USB2_HC_PROTOCOL instance.\r
  @param  MaxSpeed              Max speed supported by the controller.\r
  @param  PortNumber            Number of the root hub ports.\r
  @param  Is64BitCapable        Whether the controller supports 64-bit memory\r
                                addressing.\r
\r
  @retval EFI_SUCCESS           Host controller capability were retrieved successfully.\r
  @retval EFI_INVALID_PARAMETER Either of the three capability pointer is NULL.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcGetCapability (\r
  IN  EFI_USB2_HC_PROTOCOL  *This,\r
  OUT UINT8                 *MaxSpeed,\r
  OUT UINT8                 *PortNumber,\r
  OUT UINT8                 *Is64BitCapable\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  EFI_TPL            OldTpl;\r
\r
  if ((MaxSpeed == NULL) || (PortNumber == NULL) || (Is64BitCapable == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc             = XHC_FROM_THIS (This);\r
  *MaxSpeed       = EFI_USB_SPEED_SUPER;\r
  *PortNumber     = (UINT8)(Xhc->HcSParams1.Data.MaxPorts);\r
  *Is64BitCapable = (UINT8)Xhc->Support64BitDma;\r
  DEBUG ((DEBUG_INFO, "XhcGetCapability: %d ports, 64 bit %d\n", *PortNumber, *Is64BitCapable));\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Provides software reset for the USB host controller.\r
\r
  @param  This                  This EFI_USB2_HC_PROTOCOL instance.\r
  @param  Attributes            A bit mask of the reset operation to perform.\r
\r
  @retval EFI_SUCCESS           The reset operation succeeded.\r
  @retval EFI_INVALID_PARAMETER Attributes is not valid.\r
  @retval EFI_UNSUPPOURTED      The type of reset specified by Attributes is\r
                                not currently supported by the host controller.\r
  @retval EFI_DEVICE_ERROR      Host controller isn't halted to reset.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcReset (\r
  IN EFI_USB2_HC_PROTOCOL  *This,\r
  IN UINT16                Attributes\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  EFI_STATUS         Status;\r
  EFI_TPL            OldTpl;\r
\r
  Xhc = XHC_FROM_THIS (This);\r
\r
  if (Xhc->DevicePath != NULL) {\r
    //\r
    // Report Status Code to indicate reset happens\r
    //\r
    REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
      EFI_PROGRESS_CODE,\r
      (EFI_IO_BUS_USB | EFI_IOB_PC_RESET),\r
      Xhc->DevicePath\r
      );\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  switch (Attributes) {\r
    case EFI_USB_HC_RESET_GLOBAL:\r
    //\r
    // Flow through, same behavior as Host Controller Reset\r
    //\r
    case EFI_USB_HC_RESET_HOST_CONTROLLER:\r
      if ((Xhc->DebugCapSupOffset != 0xFFFFFFFF) && ((XhcReadExtCapReg (Xhc, Xhc->DebugCapSupOffset) & 0xFF) == XHC_CAP_USB_DEBUG) &&\r
          ((XhcReadExtCapReg (Xhc, Xhc->DebugCapSupOffset + XHC_DC_DCCTRL) & BIT0) != 0))\r
      {\r
        Status = EFI_SUCCESS;\r
        goto ON_EXIT;\r
      }\r
\r
      //\r
      // Host Controller must be Halt when Reset it\r
      //\r
      if (!XhcIsHalt (Xhc)) {\r
        Status = XhcHaltHC (Xhc, XHC_GENERIC_TIMEOUT);\r
\r
        if (EFI_ERROR (Status)) {\r
          Status = EFI_DEVICE_ERROR;\r
          goto ON_EXIT;\r
        }\r
      }\r
\r
      Status = XhcResetHC (Xhc, XHC_RESET_TIMEOUT);\r
      ASSERT (!(XHC_REG_BIT_IS_SET (Xhc, XHC_USBSTS_OFFSET, XHC_USBSTS_CNR)));\r
\r
      if (EFI_ERROR (Status)) {\r
        goto ON_EXIT;\r
      }\r
\r
      //\r
      // Clean up the asynchronous transfers, currently only\r
      // interrupt supports asynchronous operation.\r
      //\r
      XhciDelAllAsyncIntTransfers (Xhc);\r
      XhcFreeSched (Xhc);\r
\r
      XhcInitSched (Xhc);\r
      break;\r
\r
    case EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG:\r
    case EFI_USB_HC_RESET_HOST_WITH_DEBUG:\r
      Status = EFI_UNSUPPORTED;\r
      break;\r
\r
    default:\r
      Status = EFI_INVALID_PARAMETER;\r
  }\r
\r
ON_EXIT:\r
  DEBUG ((DEBUG_INFO, "XhcReset: status %r\n", Status));\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Retrieve the current state of the USB host controller.\r
\r
  @param  This                   This EFI_USB2_HC_PROTOCOL instance.\r
  @param  State                  Variable to return the current host controller\r
                                 state.\r
\r
  @retval EFI_SUCCESS            Host controller state was returned in State.\r
  @retval EFI_INVALID_PARAMETER  State is NULL.\r
  @retval EFI_DEVICE_ERROR       An error was encountered while attempting to\r
                                 retrieve the host controller's current state.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcGetState (\r
  IN  EFI_USB2_HC_PROTOCOL  *This,\r
  OUT EFI_USB_HC_STATE      *State\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  EFI_TPL            OldTpl;\r
\r
  if (State == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc = XHC_FROM_THIS (This);\r
\r
  if (XHC_REG_BIT_IS_SET (Xhc, XHC_USBSTS_OFFSET, XHC_USBSTS_HALT)) {\r
    *State = EfiUsbHcStateHalt;\r
  } else {\r
    *State = EfiUsbHcStateOperational;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "XhcGetState: current state %d\n", *State));\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Sets the USB host controller to a specific state.\r
\r
  @param  This                  This EFI_USB2_HC_PROTOCOL instance.\r
  @param  State                 The state of the host controller that will be set.\r
\r
  @retval EFI_SUCCESS           The USB host controller was successfully placed\r
                                in the state specified by State.\r
  @retval EFI_INVALID_PARAMETER State is invalid.\r
  @retval EFI_DEVICE_ERROR      Failed to set the state due to device error.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcSetState (\r
  IN EFI_USB2_HC_PROTOCOL  *This,\r
  IN EFI_USB_HC_STATE      State\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  EFI_STATUS         Status;\r
  EFI_USB_HC_STATE   CurState;\r
  EFI_TPL            OldTpl;\r
\r
  Status = XhcGetState (This, &CurState);\r
\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  if (CurState == State) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc = XHC_FROM_THIS (This);\r
\r
  switch (State) {\r
    case EfiUsbHcStateHalt:\r
      Status = XhcHaltHC (Xhc, XHC_GENERIC_TIMEOUT);\r
      break;\r
\r
    case EfiUsbHcStateOperational:\r
      if (XHC_REG_BIT_IS_SET (Xhc, XHC_USBSTS_OFFSET, XHC_USBSTS_HSE)) {\r
        Status = EFI_DEVICE_ERROR;\r
        break;\r
      }\r
\r
      //\r
      // Software must not write a one to this field unless the host controller\r
      // is in the Halted state. Doing so will yield undefined results.\r
      // refers to Spec[XHCI1.0-2.3.1]\r
      //\r
      if (!XHC_REG_BIT_IS_SET (Xhc, XHC_USBSTS_OFFSET, XHC_USBSTS_HALT)) {\r
        Status = EFI_DEVICE_ERROR;\r
        break;\r
      }\r
\r
      Status = XhcRunHC (Xhc, XHC_GENERIC_TIMEOUT);\r
      break;\r
\r
    case EfiUsbHcStateSuspend:\r
      Status = EFI_UNSUPPORTED;\r
      break;\r
\r
    default:\r
      Status = EFI_INVALID_PARAMETER;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "XhcSetState: status %r\n", Status));\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Retrieves the current status of a USB root hub port.\r
\r
  @param  This                  This EFI_USB2_HC_PROTOCOL instance.\r
  @param  PortNumber            The root hub port to retrieve the state from.\r
                                This value is zero-based.\r
  @param  PortStatus            Variable to receive the port state.\r
\r
  @retval EFI_SUCCESS           The status of the USB root hub port specified.\r
                                by PortNumber was returned in PortStatus.\r
  @retval EFI_INVALID_PARAMETER PortNumber is invalid.\r
  @retval EFI_DEVICE_ERROR      Can't read register.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcGetRootHubPortStatus (\r
  IN  EFI_USB2_HC_PROTOCOL  *This,\r
  IN  UINT8                 PortNumber,\r
  OUT EFI_USB_PORT_STATUS   *PortStatus\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  UINT32             Offset;\r
  UINT32             State;\r
  UINT32             TotalPort;\r
  UINTN              Index;\r
  UINTN              MapSize;\r
  EFI_STATUS         Status;\r
  USB_DEV_ROUTE      ParentRouteChart;\r
  EFI_TPL            OldTpl;\r
\r
  if (PortStatus == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc    = XHC_FROM_THIS (This);\r
  Status = EFI_SUCCESS;\r
\r
  TotalPort = Xhc->HcSParams1.Data.MaxPorts;\r
\r
  if (PortNumber >= TotalPort) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto ON_EXIT;\r
  }\r
\r
  Offset                       = (UINT32)(XHC_PORTSC_OFFSET + (0x10 * PortNumber));\r
  PortStatus->PortStatus       = 0;\r
  PortStatus->PortChangeStatus = 0;\r
\r
  State = XhcReadOpReg (Xhc, Offset);\r
\r
  //\r
  // According to XHCI 1.1 spec November 2017,\r
  // bit 10~13 of the root port status register identifies the speed of the attached device.\r
  //\r
  switch ((State & XHC_PORTSC_PS) >> 10) {\r
    case 2:\r
      PortStatus->PortStatus |= USB_PORT_STAT_LOW_SPEED;\r
      break;\r
\r
    case 3:\r
      PortStatus->PortStatus |= USB_PORT_STAT_HIGH_SPEED;\r
      break;\r
\r
    case 4:\r
    case 5:\r
      PortStatus->PortStatus |= USB_PORT_STAT_SUPER_SPEED;\r
      break;\r
\r
    default:\r
      break;\r
  }\r
\r
  //\r
  // Convert the XHCI port/port change state to UEFI status\r
  //\r
  MapSize = sizeof (mUsbPortStateMap) / sizeof (USB_PORT_STATE_MAP);\r
\r
  for (Index = 0; Index < MapSize; Index++) {\r
    if (XHC_BIT_IS_SET (State, mUsbPortStateMap[Index].HwState)) {\r
      PortStatus->PortStatus = (UINT16)(PortStatus->PortStatus | mUsbPortStateMap[Index].UefiState);\r
    }\r
  }\r
\r
  //\r
  // Bit5~8 reflects its current link state.\r
  //\r
  if ((State & XHC_PORTSC_PLS) >> 5 == 3) {\r
    PortStatus->PortStatus |= USB_PORT_STAT_SUSPEND;\r
  }\r
\r
  MapSize = sizeof (mUsbPortChangeMap) / sizeof (USB_PORT_STATE_MAP);\r
\r
  for (Index = 0; Index < MapSize; Index++) {\r
    if (XHC_BIT_IS_SET (State, mUsbPortChangeMap[Index].HwState)) {\r
      PortStatus->PortChangeStatus = (UINT16)(PortStatus->PortChangeStatus | mUsbPortChangeMap[Index].UefiState);\r
    }\r
  }\r
\r
  MapSize = sizeof (mUsbClearPortChangeMap) / sizeof (USB_CLEAR_PORT_MAP);\r
\r
  for (Index = 0; Index < MapSize; Index++) {\r
    if (XHC_BIT_IS_SET (State, mUsbClearPortChangeMap[Index].HwState)) {\r
      XhcClearRootHubPortFeature (This, PortNumber, (EFI_USB_PORT_FEATURE)mUsbClearPortChangeMap[Index].Selector);\r
    }\r
  }\r
\r
  //\r
  // Poll the root port status register to enable/disable corresponding device slot if there is a device attached/detached.\r
  // For those devices behind hub, we get its attach/detach event by hooking Get_Port_Status request at control transfer for those hub.\r
  //\r
  ParentRouteChart.Dword = 0;\r
  XhcPollPortStatusChange (Xhc, ParentRouteChart, PortNumber, PortStatus);\r
\r
ON_EXIT:\r
  gBS->RestoreTPL (OldTpl);\r
  return Status;\r
}\r
\r
/**\r
  Sets a feature for the specified root hub port.\r
\r
  @param  This                  This EFI_USB2_HC_PROTOCOL instance.\r
  @param  PortNumber            Root hub port to set.\r
  @param  PortFeature           Feature to set.\r
\r
  @retval EFI_SUCCESS           The feature specified by PortFeature was set.\r
  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.\r
  @retval EFI_DEVICE_ERROR      Can't read register.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcSetRootHubPortFeature (\r
  IN EFI_USB2_HC_PROTOCOL  *This,\r
  IN UINT8                 PortNumber,\r
  IN EFI_USB_PORT_FEATURE  PortFeature\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  UINT32             Offset;\r
  UINT32             State;\r
  UINT32             TotalPort;\r
  EFI_STATUS         Status;\r
  EFI_TPL            OldTpl;\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc    = XHC_FROM_THIS (This);\r
  Status = EFI_SUCCESS;\r
\r
  TotalPort = (Xhc->HcSParams1.Data.MaxPorts);\r
\r
  if (PortNumber >= TotalPort) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto ON_EXIT;\r
  }\r
\r
  Offset = (UINT32)(XHC_PORTSC_OFFSET + (0x10 * PortNumber));\r
  State  = XhcReadOpReg (Xhc, Offset);\r
\r
  //\r
  // Mask off the port status change bits, these bits are\r
  // write clean bit\r
  //\r
  State &= ~(BIT1 | BIT17 | BIT18 | BIT19 | BIT20 | BIT21 | BIT22 | BIT23);\r
\r
  switch (PortFeature) {\r
    case EfiUsbPortEnable:\r
      //\r
      // Ports may only be enabled by the xHC. Software cannot enable a port by writing a '1' to this flag.\r
      // A port may be disabled by software writing a '1' to this flag.\r
      //\r
      Status = EFI_SUCCESS;\r
      break;\r
\r
    case EfiUsbPortSuspend:\r
      State |= XHC_PORTSC_LWS;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      State &= ~XHC_PORTSC_PLS;\r
      State |= (3 << 5);\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      break;\r
\r
    case EfiUsbPortReset:\r
      DEBUG ((DEBUG_INFO, "XhcUsbPortReset!\n"));\r
      //\r
      // Make sure Host Controller not halt before reset it\r
      //\r
      if (XhcIsHalt (Xhc)) {\r
        Status = XhcRunHC (Xhc, XHC_GENERIC_TIMEOUT);\r
\r
        if (EFI_ERROR (Status)) {\r
          DEBUG ((DEBUG_INFO, "XhcSetRootHubPortFeature :failed to start HC - %r\n", Status));\r
          break;\r
        }\r
      }\r
\r
      //\r
      // 4.3.1 Resetting a Root Hub Port\r
      // 1) Write the PORTSC register with the Port Reset (PR) bit set to '1'.\r
      //\r
      State |= XHC_PORTSC_RESET;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      XhcWaitOpRegBit (Xhc, Offset, XHC_PORTSC_PRC, TRUE, XHC_GENERIC_TIMEOUT);\r
      break;\r
\r
    case EfiUsbPortPower:\r
      //\r
      // Not supported, ignore the operation\r
      //\r
      Status = EFI_SUCCESS;\r
      break;\r
\r
    case EfiUsbPortOwner:\r
      //\r
      // XHCI root hub port don't has the owner bit, ignore the operation\r
      //\r
      Status = EFI_SUCCESS;\r
      break;\r
\r
    default:\r
      Status = EFI_INVALID_PARAMETER;\r
  }\r
\r
ON_EXIT:\r
  DEBUG ((DEBUG_INFO, "XhcSetRootHubPortFeature: status %r\n", Status));\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Clears a feature for the specified root hub port.\r
\r
  @param  This                  A pointer to the EFI_USB2_HC_PROTOCOL instance.\r
  @param  PortNumber            Specifies the root hub port whose feature is\r
                                requested to be cleared.\r
  @param  PortFeature           Indicates the feature selector associated with the\r
                                feature clear request.\r
\r
  @retval EFI_SUCCESS           The feature specified by PortFeature was cleared\r
                                for the USB root hub port specified by PortNumber.\r
  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.\r
  @retval EFI_DEVICE_ERROR      Can't read register.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcClearRootHubPortFeature (\r
  IN EFI_USB2_HC_PROTOCOL  *This,\r
  IN UINT8                 PortNumber,\r
  IN EFI_USB_PORT_FEATURE  PortFeature\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  UINT32             Offset;\r
  UINT32             State;\r
  UINT32             TotalPort;\r
  EFI_STATUS         Status;\r
  EFI_TPL            OldTpl;\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc    = XHC_FROM_THIS (This);\r
  Status = EFI_SUCCESS;\r
\r
  TotalPort = (Xhc->HcSParams1.Data.MaxPorts);\r
\r
  if (PortNumber >= TotalPort) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto ON_EXIT;\r
  }\r
\r
  Offset = XHC_PORTSC_OFFSET + (0x10 * PortNumber);\r
\r
  //\r
  // Mask off the port status change bits, these bits are\r
  // write clean bit\r
  //\r
  State  = XhcReadOpReg (Xhc, Offset);\r
  State &= ~(BIT1 | BIT17 | BIT18 | BIT19 | BIT20 | BIT21 | BIT22 | BIT23);\r
\r
  switch (PortFeature) {\r
    case EfiUsbPortEnable:\r
      //\r
      // Ports may only be enabled by the xHC. Software cannot enable a port by writing a '1' to this flag.\r
      // A port may be disabled by software writing a '1' to this flag.\r
      //\r
      State |= XHC_PORTSC_PED;\r
      State &= ~XHC_PORTSC_RESET;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      break;\r
\r
    case EfiUsbPortSuspend:\r
      State |= XHC_PORTSC_LWS;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      State &= ~XHC_PORTSC_PLS;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      break;\r
\r
    case EfiUsbPortReset:\r
      //\r
      // PORTSC_RESET BIT(4) bit is RW1S attribute, which means Write-1-to-set status:\r
      // Register bits indicate status when read, a clear bit may be set by\r
      // writing a '1'. Writing a '0' to RW1S bits has no effect.\r
      //\r
      break;\r
\r
    case EfiUsbPortOwner:\r
      //\r
      // XHCI root hub port don't has the owner bit, ignore the operation\r
      //\r
      break;\r
\r
    case EfiUsbPortConnectChange:\r
      //\r
      // Clear connect status change\r
      //\r
      State |= XHC_PORTSC_CSC;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      break;\r
\r
    case EfiUsbPortEnableChange:\r
      //\r
      // Clear enable status change\r
      //\r
      State |= XHC_PORTSC_PEC;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      break;\r
\r
    case EfiUsbPortOverCurrentChange:\r
      //\r
      // Clear PortOverCurrent change\r
      //\r
      State |= XHC_PORTSC_OCC;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      break;\r
\r
    case EfiUsbPortResetChange:\r
      //\r
      // Clear Port Reset change\r
      //\r
      State |= XHC_PORTSC_PRC;\r
      XhcWriteOpReg (Xhc, Offset, State);\r
      break;\r
\r
    case EfiUsbPortPower:\r
    case EfiUsbPortSuspendChange:\r
      //\r
      // Not supported or not related operation\r
      //\r
      break;\r
\r
    default:\r
      Status = EFI_INVALID_PARAMETER;\r
      break;\r
  }\r
\r
ON_EXIT:\r
  DEBUG ((DEBUG_INFO, "XhcClearRootHubPortFeature: status %r\n", Status));\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Submits a new transaction to a target USB device.\r
\r
  @param  Xhc                   The XHCI Instance.\r
  @param  DeviceAddress         The target device address.\r
  @param  EndPointAddress       Endpoint number and its direction encoded in bit 7\r
  @param  DeviceSpeed           Target device speed.\r
  @param  MaximumPacketLength   Maximum packet size the default control transfer\r
                                endpoint is capable of sending or receiving.\r
  @param  Type                  The transaction type.\r
  @param  Request               USB device request to send.\r
  @param  Data                  Data buffer to be transmitted or received from USB\r
                                device.\r
  @param  DataLength            The size (in bytes) of the data buffer.\r
  @param  Timeout               Indicates the maximum timeout, in millisecond.\r
  @param  TransferResult        Return the result of this control transfer.\r
\r
  @retval EFI_SUCCESS           Transfer was completed successfully.\r
  @retval EFI_OUT_OF_RESOURCES  The transfer failed due to lack of resources.\r
  @retval EFI_INVALID_PARAMETER Some parameters are invalid.\r
  @retval EFI_TIMEOUT           Transfer failed due to timeout.\r
  @retval EFI_DEVICE_ERROR      Transfer failed due to host controller or device error.\r
**/\r
EFI_STATUS\r
XhcTransfer (\r
  IN     USB_XHCI_INSTANCE       *Xhc,\r
  IN     UINT8                   DeviceAddress,\r
  IN     UINT8                   EndPointAddress,\r
  IN     UINT8                   DeviceSpeed,\r
  IN     UINTN                   MaximumPacketLength,\r
  IN     UINTN                   Type,\r
  IN     EFI_USB_DEVICE_REQUEST  *Request,\r
  IN OUT VOID                    *Data,\r
  IN OUT UINTN                   *DataLength,\r
  IN     UINTN                   Timeout,\r
  OUT    UINT32                  *TransferResult\r
  )\r
{\r
  EFI_STATUS  Status;\r
  EFI_STATUS  RecoveryStatus;\r
  URB         *Urb;\r
\r
  ASSERT ((Type == XHC_CTRL_TRANSFER) || (Type == XHC_BULK_TRANSFER) || (Type == XHC_INT_TRANSFER_SYNC));\r
  Urb = XhcCreateUrb (\r
          Xhc,\r
          DeviceAddress,\r
          EndPointAddress,\r
          DeviceSpeed,\r
          MaximumPacketLength,\r
          Type,\r
          Request,\r
          Data,\r
          *DataLength,\r
          NULL,\r
          NULL\r
          );\r
\r
  if (Urb == NULL) {\r
    DEBUG ((DEBUG_ERROR, "XhcTransfer[Type=%d]: failed to create URB!\n", Type));\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Status = XhcExecTransfer (Xhc, FALSE, Urb, Timeout);\r
\r
  if (Status == EFI_TIMEOUT) {\r
    //\r
    // The transfer timed out. Abort the transfer by dequeueing of the TD.\r
    //\r
    RecoveryStatus = XhcDequeueTrbFromEndpoint (Xhc, Urb);\r
    if (RecoveryStatus == EFI_ALREADY_STARTED) {\r
      //\r
      // The URB is finished just before stopping endpoint.\r
      // Change returning status from EFI_TIMEOUT to EFI_SUCCESS.\r
      //\r
      ASSERT (Urb->Result == EFI_USB_NOERROR);\r
      Status = EFI_SUCCESS;\r
      DEBUG ((DEBUG_ERROR, "XhcTransfer[Type=%d]: pending URB is finished, Length = %d.\n", Type, Urb->Completed));\r
    } else if (EFI_ERROR (RecoveryStatus)) {\r
      DEBUG ((DEBUG_ERROR, "XhcTransfer[Type=%d]: XhcDequeueTrbFromEndpoint failed!\n", Type));\r
    }\r
  }\r
\r
  *TransferResult = Urb->Result;\r
  *DataLength     = Urb->Completed;\r
\r
  if ((*TransferResult == EFI_USB_ERR_STALL) || (*TransferResult == EFI_USB_ERR_BABBLE)) {\r
    ASSERT (Status == EFI_DEVICE_ERROR);\r
    RecoveryStatus = XhcRecoverHaltedEndpoint (Xhc, Urb);\r
    if (EFI_ERROR (RecoveryStatus)) {\r
      DEBUG ((DEBUG_ERROR, "XhcTransfer[Type=%d]: XhcRecoverHaltedEndpoint failed!\n", Type));\r
    }\r
  }\r
\r
  Xhc->PciIo->Flush (Xhc->PciIo);\r
  XhcFreeUrb (Xhc, Urb);\r
  return Status;\r
}\r
\r
/**\r
  Submits control transfer to a target USB device.\r
\r
  @param  This                  This EFI_USB2_HC_PROTOCOL instance.\r
  @param  DeviceAddress         The target device address.\r
  @param  DeviceSpeed           Target device speed.\r
  @param  MaximumPacketLength   Maximum packet size the default control transfer\r
                                endpoint is capable of sending or receiving.\r
  @param  Request               USB device request to send.\r
  @param  TransferDirection     Specifies the data direction for the data stage\r
  @param  Data                  Data buffer to be transmitted or received from USB\r
                                device.\r
  @param  DataLength            The size (in bytes) of the data buffer.\r
  @param  Timeout               Indicates the maximum timeout, in millisecond.\r
  @param  Translator            Transaction translator to be used by this device.\r
  @param  TransferResult        Return the result of this control transfer.\r
\r
  @retval EFI_SUCCESS           Transfer was completed successfully.\r
  @retval EFI_OUT_OF_RESOURCES  The transfer failed due to lack of resources.\r
  @retval EFI_INVALID_PARAMETER Some parameters are invalid.\r
  @retval EFI_TIMEOUT           Transfer failed due to timeout.\r
  @retval EFI_DEVICE_ERROR      Transfer failed due to host controller or device error.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcControlTransfer (\r
  IN     EFI_USB2_HC_PROTOCOL                *This,\r
  IN     UINT8                               DeviceAddress,\r
  IN     UINT8                               DeviceSpeed,\r
  IN     UINTN                               MaximumPacketLength,\r
  IN     EFI_USB_DEVICE_REQUEST              *Request,\r
  IN     EFI_USB_DATA_DIRECTION              TransferDirection,\r
  IN OUT VOID                                *Data,\r
  IN OUT UINTN                               *DataLength,\r
  IN     UINTN                               Timeout,\r
  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,\r
  OUT    UINT32                              *TransferResult\r
  )\r
{\r
  USB_XHCI_INSTANCE       *Xhc;\r
  UINT8                   Endpoint;\r
  UINT8                   Index;\r
  UINT8                   DescriptorType;\r
  UINT8                   SlotId;\r
  UINT8                   TTT;\r
  UINT8                   MTT;\r
  UINT32                  MaxPacket0;\r
  EFI_USB_HUB_DESCRIPTOR  *HubDesc;\r
  EFI_TPL                 OldTpl;\r
  EFI_STATUS              Status;\r
  UINTN                   MapSize;\r
  EFI_USB_PORT_STATUS     PortStatus;\r
  UINT32                  State;\r
  EFI_USB_DEVICE_REQUEST  ClearPortRequest;\r
  UINTN                   Len;\r
\r
  //\r
  // Validate parameters\r
  //\r
  if ((Request == NULL) || (TransferResult == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((TransferDirection != EfiUsbDataIn) &&\r
      (TransferDirection != EfiUsbDataOut) &&\r
      (TransferDirection != EfiUsbNoData))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((TransferDirection == EfiUsbNoData) &&\r
      ((Data != NULL) || (*DataLength != 0)))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((TransferDirection != EfiUsbNoData) &&\r
      ((Data == NULL) || (*DataLength == 0)))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((MaximumPacketLength != 8)  && (MaximumPacketLength != 16) &&\r
      (MaximumPacketLength != 32) && (MaximumPacketLength != 64) &&\r
      (MaximumPacketLength != 512)\r
      )\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((DeviceSpeed == EFI_USB_SPEED_LOW) && (MaximumPacketLength != 8)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((DeviceSpeed == EFI_USB_SPEED_SUPER) && (MaximumPacketLength != 512)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc = XHC_FROM_THIS (This);\r
\r
  Status          = EFI_DEVICE_ERROR;\r
  *TransferResult = EFI_USB_ERR_SYSTEM;\r
  Len             = 0;\r
\r
  if (XhcIsHalt (Xhc) || XhcIsSysError (Xhc)) {\r
    DEBUG ((DEBUG_ERROR, "XhcControlTransfer: HC halted at entrance\n"));\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Check if the device is still enabled before every transaction.\r
  //\r
  SlotId = XhcBusDevAddrToSlotId (Xhc, DeviceAddress);\r
  if (SlotId == 0) {\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Hook the Set_Address request from UsbBus.\r
  // According to XHCI 1.0 spec, the Set_Address request is replaced by XHCI's Address_Device cmd.\r
  //\r
  if ((Request->Request     == USB_REQ_SET_ADDRESS) &&\r
      (Request->RequestType == USB_REQUEST_TYPE (EfiUsbNoData, USB_REQ_TYPE_STANDARD, USB_TARGET_DEVICE)))\r
  {\r
    //\r
    // Reset the BusDevAddr field of all disabled entries in UsbDevContext array firstly.\r
    // This way is used to clean the history to avoid using wrong device address by XhcAsyncInterruptTransfer().\r
    //\r
    for (Index = 0; Index < 255; Index++) {\r
      if (!Xhc->UsbDevContext[Index + 1].Enabled &&\r
          (Xhc->UsbDevContext[Index + 1].SlotId == 0) &&\r
          (Xhc->UsbDevContext[Index + 1].BusDevAddr == (UINT8)Request->Value))\r
      {\r
        Xhc->UsbDevContext[Index + 1].BusDevAddr = 0;\r
      }\r
    }\r
\r
    if (Xhc->UsbDevContext[SlotId].XhciDevAddr == 0) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto ON_EXIT;\r
    }\r
\r
    //\r
    // The actual device address has been assigned by XHCI during initializing the device slot.\r
    // So we just need establish the mapping relationship between the device address requested from UsbBus\r
    // and the actual device address assigned by XHCI. The the following invocations through EFI_USB2_HC_PROTOCOL interface\r
    // can find out the actual device address by it.\r
    //\r
    Xhc->UsbDevContext[SlotId].BusDevAddr = (UINT8)Request->Value;\r
    Status                                = EFI_SUCCESS;\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Create a new URB, insert it into the asynchronous\r
  // schedule list, then poll the execution status.\r
  // Note that we encode the direction in address although default control\r
  // endpoint is bidirectional. XhcCreateUrb expects this\r
  // combination of Ep addr and its direction.\r
  //\r
  Endpoint = (UINT8)(0 | ((TransferDirection == EfiUsbDataIn) ? 0x80 : 0));\r
  Status   = XhcTransfer (\r
               Xhc,\r
               DeviceAddress,\r
               Endpoint,\r
               DeviceSpeed,\r
               MaximumPacketLength,\r
               XHC_CTRL_TRANSFER,\r
               Request,\r
               Data,\r
               DataLength,\r
               Timeout,\r
               TransferResult\r
               );\r
\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Hook Get_Descriptor request from UsbBus as we need evaluate context and configure endpoint.\r
  // Hook Get_Status request form UsbBus as we need trace device attach/detach event happened at hub.\r
  // Hook Set_Config request from UsbBus as we need configure device endpoint.\r
  //\r
  if ((Request->Request     == USB_REQ_GET_DESCRIPTOR) &&\r
      ((Request->RequestType == USB_REQUEST_TYPE (EfiUsbDataIn, USB_REQ_TYPE_STANDARD, USB_TARGET_DEVICE)) ||\r
       ((Request->RequestType == USB_REQUEST_TYPE (EfiUsbDataIn, USB_REQ_TYPE_CLASS, USB_TARGET_DEVICE)))))\r
  {\r
    DescriptorType = (UINT8)(Request->Value >> 8);\r
    if ((DescriptorType == USB_DESC_TYPE_DEVICE) && ((*DataLength == sizeof (EFI_USB_DEVICE_DESCRIPTOR)) || ((DeviceSpeed == EFI_USB_SPEED_FULL) && (*DataLength == 8)))) {\r
      ASSERT (Data != NULL);\r
      //\r
      // Store a copy of device scriptor as hub device need this info to configure endpoint.\r
      //\r
      CopyMem (&Xhc->UsbDevContext[SlotId].DevDesc, Data, *DataLength);\r
      if (Xhc->UsbDevContext[SlotId].DevDesc.BcdUSB >= 0x0300) {\r
        //\r
        // If it's a usb3.0 device, then its max packet size is a 2^n.\r
        //\r
        MaxPacket0 = 1 << Xhc->UsbDevContext[SlotId].DevDesc.MaxPacketSize0;\r
      } else {\r
        MaxPacket0 = Xhc->UsbDevContext[SlotId].DevDesc.MaxPacketSize0;\r
      }\r
\r
      Xhc->UsbDevContext[SlotId].ConfDesc = AllocateZeroPool (Xhc->UsbDevContext[SlotId].DevDesc.NumConfigurations * sizeof (EFI_USB_CONFIG_DESCRIPTOR *));\r
      if (Xhc->HcCParams.Data.Csz == 0) {\r
        Status = XhcEvaluateContext (Xhc, SlotId, MaxPacket0);\r
      } else {\r
        Status = XhcEvaluateContext64 (Xhc, SlotId, MaxPacket0);\r
      }\r
    } else if (DescriptorType == USB_DESC_TYPE_CONFIG) {\r
      ASSERT (Data != NULL);\r
      if (*DataLength == ((UINT16 *)Data)[1]) {\r
        //\r
        // Get configuration value from request, Store the configuration descriptor for Configure_Endpoint cmd.\r
        //\r
        Index = (UINT8)Request->Value;\r
        ASSERT (Index < Xhc->UsbDevContext[SlotId].DevDesc.NumConfigurations);\r
        Xhc->UsbDevContext[SlotId].ConfDesc[Index] = AllocateZeroPool (*DataLength);\r
        CopyMem (Xhc->UsbDevContext[SlotId].ConfDesc[Index], Data, *DataLength);\r
        //\r
        // Default to use AlternateSetting 0 for all interfaces.\r
        //\r
        Xhc->UsbDevContext[SlotId].ActiveAlternateSetting = AllocateZeroPool (Xhc->UsbDevContext[SlotId].ConfDesc[Index]->NumInterfaces * sizeof (UINT8));\r
      }\r
    } else if (((DescriptorType == USB_DESC_TYPE_HUB) ||\r
                (DescriptorType == USB_DESC_TYPE_HUB_SUPER_SPEED)) && (*DataLength > 2))\r
    {\r
      ASSERT (Data != NULL);\r
      HubDesc = (EFI_USB_HUB_DESCRIPTOR *)Data;\r
      ASSERT (HubDesc->NumPorts <= 15);\r
      //\r
      // The bit 5,6 of HubCharacter field of Hub Descriptor is TTT.\r
      //\r
      TTT = (UINT8)((HubDesc->HubCharacter & (BIT5 | BIT6)) >> 5);\r
      if (Xhc->UsbDevContext[SlotId].DevDesc.DeviceProtocol == 2) {\r
        //\r
        // Don't support multi-TT feature for super speed hub now.\r
        //\r
        MTT = 0;\r
        DEBUG ((DEBUG_ERROR, "XHCI: Don't support multi-TT feature for Hub now. (force to disable MTT)\n"));\r
      } else {\r
        MTT = 0;\r
      }\r
\r
      if (Xhc->HcCParams.Data.Csz == 0) {\r
        Status = XhcConfigHubContext (Xhc, SlotId, HubDesc->NumPorts, TTT, MTT);\r
      } else {\r
        Status = XhcConfigHubContext64 (Xhc, SlotId, HubDesc->NumPorts, TTT, MTT);\r
      }\r
    }\r
  } else if ((Request->Request     == USB_REQ_SET_CONFIG) &&\r
             (Request->RequestType == USB_REQUEST_TYPE (EfiUsbNoData, USB_REQ_TYPE_STANDARD, USB_TARGET_DEVICE)))\r
  {\r
    //\r
    // Hook Set_Config request from UsbBus as we need configure device endpoint.\r
    //\r
    for (Index = 0; Index < Xhc->UsbDevContext[SlotId].DevDesc.NumConfigurations; Index++) {\r
      if (Xhc->UsbDevContext[SlotId].ConfDesc[Index]->ConfigurationValue == (UINT8)Request->Value) {\r
        if (Xhc->HcCParams.Data.Csz == 0) {\r
          Status = XhcSetConfigCmd (Xhc, SlotId, DeviceSpeed, Xhc->UsbDevContext[SlotId].ConfDesc[Index]);\r
        } else {\r
          Status = XhcSetConfigCmd64 (Xhc, SlotId, DeviceSpeed, Xhc->UsbDevContext[SlotId].ConfDesc[Index]);\r
        }\r
\r
        break;\r
      }\r
    }\r
  } else if ((Request->Request     == USB_REQ_SET_INTERFACE) &&\r
             (Request->RequestType == USB_REQUEST_TYPE (EfiUsbNoData, USB_REQ_TYPE_STANDARD, USB_TARGET_INTERFACE)))\r
  {\r
    //\r
    // Hook Set_Interface request from UsbBus as we need configure interface setting.\r
    // Request->Value indicates AlterlateSetting to set\r
    // Request->Index indicates Interface to set\r
    //\r
    if (Xhc->UsbDevContext[SlotId].ActiveAlternateSetting[(UINT8)Request->Index] != (UINT8)Request->Value) {\r
      if (Xhc->HcCParams.Data.Csz == 0) {\r
        Status = XhcSetInterface (Xhc, SlotId, DeviceSpeed, Xhc->UsbDevContext[SlotId].ConfDesc[Xhc->UsbDevContext[SlotId].ActiveConfiguration - 1], Request);\r
      } else {\r
        Status = XhcSetInterface64 (Xhc, SlotId, DeviceSpeed, Xhc->UsbDevContext[SlotId].ConfDesc[Xhc->UsbDevContext[SlotId].ActiveConfiguration - 1], Request);\r
      }\r
    }\r
  } else if ((Request->Request     == USB_REQ_GET_STATUS) &&\r
             (Request->RequestType == USB_REQUEST_TYPE (EfiUsbDataIn, USB_REQ_TYPE_CLASS, USB_TARGET_OTHER)))\r
  {\r
    ASSERT (Data != NULL);\r
    //\r
    // Hook Get_Status request from UsbBus to keep track of the port status change.\r
    //\r
    State                       = *(UINT32 *)Data;\r
    PortStatus.PortStatus       = 0;\r
    PortStatus.PortChangeStatus = 0;\r
\r
    if (DeviceSpeed == EFI_USB_SPEED_SUPER) {\r
      //\r
      // For super speed hub, its bit10~12 presents the attached device speed.\r
      //\r
      if ((State & XHC_PORTSC_PS) >> 10 == 0) {\r
        PortStatus.PortStatus |= USB_PORT_STAT_SUPER_SPEED;\r
      }\r
    } else {\r
      //\r
      // For high or full/low speed hub, its bit9~10 presents the attached device speed.\r
      //\r
      if (XHC_BIT_IS_SET (State, BIT9)) {\r
        PortStatus.PortStatus |= USB_PORT_STAT_LOW_SPEED;\r
      } else if (XHC_BIT_IS_SET (State, BIT10)) {\r
        PortStatus.PortStatus |= USB_PORT_STAT_HIGH_SPEED;\r
      }\r
    }\r
\r
    //\r
    // Convert the XHCI port/port change state to UEFI status\r
    //\r
    MapSize = sizeof (mUsbHubPortStateMap) / sizeof (USB_PORT_STATE_MAP);\r
    for (Index = 0; Index < MapSize; Index++) {\r
      if (XHC_BIT_IS_SET (State, mUsbHubPortStateMap[Index].HwState)) {\r
        PortStatus.PortStatus = (UINT16)(PortStatus.PortStatus | mUsbHubPortStateMap[Index].UefiState);\r
      }\r
    }\r
\r
    MapSize = sizeof (mUsbHubPortChangeMap) / sizeof (USB_PORT_STATE_MAP);\r
    for (Index = 0; Index < MapSize; Index++) {\r
      if (XHC_BIT_IS_SET (State, mUsbHubPortChangeMap[Index].HwState)) {\r
        PortStatus.PortChangeStatus = (UINT16)(PortStatus.PortChangeStatus | mUsbHubPortChangeMap[Index].UefiState);\r
      }\r
    }\r
\r
    MapSize = sizeof (mUsbHubClearPortChangeMap) / sizeof (USB_CLEAR_PORT_MAP);\r
\r
    for (Index = 0; Index < MapSize; Index++) {\r
      if (XHC_BIT_IS_SET (State, mUsbHubClearPortChangeMap[Index].HwState)) {\r
        ZeroMem (&ClearPortRequest, sizeof (EFI_USB_DEVICE_REQUEST));\r
        ClearPortRequest.RequestType = USB_REQUEST_TYPE (EfiUsbNoData, USB_REQ_TYPE_CLASS, USB_TARGET_OTHER);\r
        ClearPortRequest.Request     = (UINT8)USB_REQ_CLEAR_FEATURE;\r
        ClearPortRequest.Value       = mUsbHubClearPortChangeMap[Index].Selector;\r
        ClearPortRequest.Index       = Request->Index;\r
        ClearPortRequest.Length      = 0;\r
\r
        XhcControlTransfer (\r
          This,\r
          DeviceAddress,\r
          DeviceSpeed,\r
          MaximumPacketLength,\r
          &ClearPortRequest,\r
          EfiUsbNoData,\r
          NULL,\r
          &Len,\r
          Timeout,\r
          Translator,\r
          TransferResult\r
          );\r
      }\r
    }\r
\r
    XhcPollPortStatusChange (Xhc, Xhc->UsbDevContext[SlotId].RouteString, (UINT8)Request->Index, &PortStatus);\r
\r
    *(UINT32 *)Data = *(UINT32 *)&PortStatus;\r
  }\r
\r
ON_EXIT:\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "XhcControlTransfer: error - %r, transfer - %x\n", Status, *TransferResult));\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Submits bulk transfer to a bulk endpoint of a USB device.\r
\r
  @param  This                  This EFI_USB2_HC_PROTOCOL instance.\r
  @param  DeviceAddress         Target device address.\r
  @param  EndPointAddress       Endpoint number and its direction in bit 7.\r
  @param  DeviceSpeed           Device speed, Low speed device doesn't support bulk\r
                                transfer.\r
  @param  MaximumPacketLength   Maximum packet size the endpoint is capable of\r
                                sending or receiving.\r
  @param  DataBuffersNumber     Number of data buffers prepared for the transfer.\r
  @param  Data                  Array of pointers to the buffers of data to transmit\r
                                from or receive into.\r
  @param  DataLength            The lenght of the data buffer.\r
  @param  DataToggle            On input, the initial data toggle for the transfer;\r
                                On output, it is updated to to next data toggle to\r
                                use of the subsequent bulk transfer.\r
  @param  Timeout               Indicates the maximum time, in millisecond, which\r
                                the transfer is allowed to complete.\r
  @param  Translator            A pointr to the transaction translator data.\r
  @param  TransferResult        A pointer to the detailed result information of the\r
                                bulk transfer.\r
\r
  @retval EFI_SUCCESS           The transfer was completed successfully.\r
  @retval EFI_OUT_OF_RESOURCES  The transfer failed due to lack of resource.\r
  @retval EFI_INVALID_PARAMETER Some parameters are invalid.\r
  @retval EFI_TIMEOUT           The transfer failed due to timeout.\r
  @retval EFI_DEVICE_ERROR      The transfer failed due to host controller error.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcBulkTransfer (\r
  IN     EFI_USB2_HC_PROTOCOL                *This,\r
  IN     UINT8                               DeviceAddress,\r
  IN     UINT8                               EndPointAddress,\r
  IN     UINT8                               DeviceSpeed,\r
  IN     UINTN                               MaximumPacketLength,\r
  IN     UINT8                               DataBuffersNumber,\r
  IN OUT VOID                                *Data[EFI_USB_MAX_BULK_BUFFER_NUM],\r
  IN OUT UINTN                               *DataLength,\r
  IN OUT UINT8                               *DataToggle,\r
  IN     UINTN                               Timeout,\r
  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,\r
  OUT    UINT32                              *TransferResult\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  UINT8              SlotId;\r
  EFI_STATUS         Status;\r
  EFI_TPL            OldTpl;\r
\r
  //\r
  // Validate the parameters\r
  //\r
  if ((DataLength == NULL) || (*DataLength == 0) ||\r
      (Data == NULL) || (Data[0] == NULL) || (TransferResult == NULL))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((*DataToggle != 0) && (*DataToggle != 1)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((DeviceSpeed == EFI_USB_SPEED_LOW) ||\r
      ((DeviceSpeed == EFI_USB_SPEED_FULL) && (MaximumPacketLength > 64)) ||\r
      ((EFI_USB_SPEED_HIGH == DeviceSpeed) && (MaximumPacketLength > 512)) ||\r
      ((EFI_USB_SPEED_SUPER == DeviceSpeed) && (MaximumPacketLength > 1024)))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc = XHC_FROM_THIS (This);\r
\r
  *TransferResult = EFI_USB_ERR_SYSTEM;\r
  Status          = EFI_DEVICE_ERROR;\r
\r
  if (XhcIsHalt (Xhc) || XhcIsSysError (Xhc)) {\r
    DEBUG ((DEBUG_ERROR, "XhcBulkTransfer: HC is halted\n"));\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Check if the device is still enabled before every transaction.\r
  //\r
  SlotId = XhcBusDevAddrToSlotId (Xhc, DeviceAddress);\r
  if (SlotId == 0) {\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Create a new URB, insert it into the asynchronous\r
  // schedule list, then poll the execution status.\r
  //\r
  Status = XhcTransfer (\r
             Xhc,\r
             DeviceAddress,\r
             EndPointAddress,\r
             DeviceSpeed,\r
             MaximumPacketLength,\r
             XHC_BULK_TRANSFER,\r
             NULL,\r
             Data[0],\r
             DataLength,\r
             Timeout,\r
             TransferResult\r
             );\r
\r
ON_EXIT:\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "XhcBulkTransfer: error - %r, transfer - %x\n", Status, *TransferResult));\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Submits an asynchronous interrupt transfer to an\r
  interrupt endpoint of a USB device.\r
\r
  @param  This                  This EFI_USB2_HC_PROTOCOL instance.\r
  @param  DeviceAddress         Target device address.\r
  @param  EndPointAddress       Endpoint number and its direction encoded in bit 7\r
  @param  DeviceSpeed           Indicates device speed.\r
  @param  MaximumPacketLength   Maximum packet size the target endpoint is capable\r
  @param  IsNewTransfer         If TRUE, to submit an new asynchronous interrupt\r
                                transfer If FALSE, to remove the specified\r
                                asynchronous interrupt.\r
  @param  DataToggle            On input, the initial data toggle to use; on output,\r
                                it is updated to indicate the next data toggle.\r
  @param  PollingInterval       The he interval, in milliseconds, that the transfer\r
                                is polled.\r
  @param  DataLength            The length of data to receive at the rate specified\r
                                by  PollingInterval.\r
  @param  Translator            Transaction translator to use.\r
  @param  CallBackFunction      Function to call at the rate specified by\r
                                PollingInterval.\r
  @param  Context               Context to CallBackFunction.\r
\r
  @retval EFI_SUCCESS           The request has been successfully submitted or canceled.\r
  @retval EFI_INVALID_PARAMETER Some parameters are invalid.\r
  @retval EFI_OUT_OF_RESOURCES  The request failed due to a lack of resources.\r
  @retval EFI_DEVICE_ERROR      The transfer failed due to host controller error.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcAsyncInterruptTransfer (\r
  IN     EFI_USB2_HC_PROTOCOL                *This,\r
  IN     UINT8                               DeviceAddress,\r
  IN     UINT8                               EndPointAddress,\r
  IN     UINT8                               DeviceSpeed,\r
  IN     UINTN                               MaximumPacketLength,\r
  IN     BOOLEAN                             IsNewTransfer,\r
  IN OUT UINT8                               *DataToggle,\r
  IN     UINTN                               PollingInterval,\r
  IN     UINTN                               DataLength,\r
  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,\r
  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK     CallBackFunction,\r
  IN     VOID                                *Context OPTIONAL\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  URB                *Urb;\r
  EFI_STATUS         Status;\r
  UINT8              SlotId;\r
  UINT8              Index;\r
  EFI_TPL            OldTpl;\r
\r
  //\r
  // Validate parameters\r
  //\r
  if (!XHCI_IS_DATAIN (EndPointAddress)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (IsNewTransfer) {\r
    if (DataLength == 0) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    if ((*DataToggle != 1) && (*DataToggle != 0)) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    if ((PollingInterval > 255) || (PollingInterval < 1)) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc = XHC_FROM_THIS (This);\r
\r
  //\r
  // Delete Async interrupt transfer request.\r
  //\r
  if (!IsNewTransfer) {\r
    //\r
    // The delete request may happen after device is detached.\r
    //\r
    for (Index = 0; Index < 255; Index++) {\r
      if (Xhc->UsbDevContext[Index + 1].BusDevAddr == DeviceAddress) {\r
        break;\r
      }\r
    }\r
\r
    if (Index == 255) {\r
      Status = EFI_INVALID_PARAMETER;\r
      goto ON_EXIT;\r
    }\r
\r
    Status = XhciDelAsyncIntTransfer (Xhc, DeviceAddress, EndPointAddress);\r
    DEBUG ((DEBUG_INFO, "XhcAsyncInterruptTransfer: remove old transfer for addr %d, Status = %r\n", DeviceAddress, Status));\r
    goto ON_EXIT;\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
  if (XhcIsHalt (Xhc) || XhcIsSysError (Xhc)) {\r
    DEBUG ((DEBUG_ERROR, "XhcAsyncInterruptTransfer: HC is halt\n"));\r
    Status = EFI_DEVICE_ERROR;\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Check if the device is still enabled before every transaction.\r
  //\r
  SlotId = XhcBusDevAddrToSlotId (Xhc, DeviceAddress);\r
  if (SlotId == 0) {\r
    goto ON_EXIT;\r
  }\r
\r
  Urb = XhciInsertAsyncIntTransfer (\r
          Xhc,\r
          DeviceAddress,\r
          EndPointAddress,\r
          DeviceSpeed,\r
          MaximumPacketLength,\r
          DataLength,\r
          CallBackFunction,\r
          Context\r
          );\r
  if (Urb == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Ring the doorbell\r
  //\r
  Status = RingIntTransferDoorBell (Xhc, Urb);\r
\r
ON_EXIT:\r
  Xhc->PciIo->Flush (Xhc->PciIo);\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Submits synchronous interrupt transfer to an interrupt endpoint\r
  of a USB device.\r
\r
  @param  This                  This EFI_USB2_HC_PROTOCOL instance.\r
  @param  DeviceAddress         Target device address.\r
  @param  EndPointAddress       Endpoint number and its direction encoded in bit 7\r
  @param  DeviceSpeed           Indicates device speed.\r
  @param  MaximumPacketLength   Maximum packet size the target endpoint is capable\r
                                of sending or receiving.\r
  @param  Data                  Buffer of data that will be transmitted to  USB\r
                                device or received from USB device.\r
  @param  DataLength            On input, the size, in bytes, of the data buffer; On\r
                                output, the number of bytes transferred.\r
  @param  DataToggle            On input, the initial data toggle to use; on output,\r
                                it is updated to indicate the next data toggle.\r
  @param  Timeout               Maximum time, in second, to complete.\r
  @param  Translator            Transaction translator to use.\r
  @param  TransferResult        Variable to receive the transfer result.\r
\r
  @return EFI_SUCCESS           The transfer was completed successfully.\r
  @return EFI_OUT_OF_RESOURCES  The transfer failed due to lack of resource.\r
  @return EFI_INVALID_PARAMETER Some parameters are invalid.\r
  @return EFI_TIMEOUT           The transfer failed due to timeout.\r
  @return EFI_DEVICE_ERROR      The failed due to host controller or device error\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcSyncInterruptTransfer (\r
  IN     EFI_USB2_HC_PROTOCOL                *This,\r
  IN     UINT8                               DeviceAddress,\r
  IN     UINT8                               EndPointAddress,\r
  IN     UINT8                               DeviceSpeed,\r
  IN     UINTN                               MaximumPacketLength,\r
  IN OUT VOID                                *Data,\r
  IN OUT UINTN                               *DataLength,\r
  IN OUT UINT8                               *DataToggle,\r
  IN     UINTN                               Timeout,\r
  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,\r
  OUT    UINT32                              *TransferResult\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  UINT8              SlotId;\r
  EFI_STATUS         Status;\r
  EFI_TPL            OldTpl;\r
\r
  //\r
  // Validates parameters\r
  //\r
  if ((DataLength == NULL) || (*DataLength == 0) ||\r
      (Data == NULL) || (TransferResult == NULL))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((*DataToggle != 1) && (*DataToggle != 0)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (((DeviceSpeed == EFI_USB_SPEED_LOW) && (MaximumPacketLength != 8))  ||\r
      ((DeviceSpeed == EFI_USB_SPEED_FULL) && (MaximumPacketLength > 64)) ||\r
      ((DeviceSpeed == EFI_USB_SPEED_HIGH) && (MaximumPacketLength > 3072)))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (XHC_TPL);\r
\r
  Xhc = XHC_FROM_THIS (This);\r
\r
  *TransferResult = EFI_USB_ERR_SYSTEM;\r
  Status          = EFI_DEVICE_ERROR;\r
\r
  if (XhcIsHalt (Xhc) || XhcIsSysError (Xhc)) {\r
    DEBUG ((DEBUG_ERROR, "EhcSyncInterruptTransfer: HC is halt\n"));\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Check if the device is still enabled before every transaction.\r
  //\r
  SlotId = XhcBusDevAddrToSlotId (Xhc, DeviceAddress);\r
  if (SlotId == 0) {\r
    goto ON_EXIT;\r
  }\r
\r
  Status = XhcTransfer (\r
             Xhc,\r
             DeviceAddress,\r
             EndPointAddress,\r
             DeviceSpeed,\r
             MaximumPacketLength,\r
             XHC_INT_TRANSFER_SYNC,\r
             NULL,\r
             Data,\r
             DataLength,\r
             Timeout,\r
             TransferResult\r
             );\r
\r
ON_EXIT:\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "XhcSyncInterruptTransfer: error - %r, transfer - %x\n", Status, *TransferResult));\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Submits isochronous transfer to a target USB device.\r
\r
  @param  This                 This EFI_USB2_HC_PROTOCOL instance.\r
  @param  DeviceAddress        Target device address.\r
  @param  EndPointAddress      End point address with its direction.\r
  @param  DeviceSpeed          Device speed, Low speed device doesn't support this\r
                               type.\r
  @param  MaximumPacketLength  Maximum packet size that the endpoint is capable of\r
                               sending or receiving.\r
  @param  DataBuffersNumber    Number of data buffers prepared for the transfer.\r
  @param  Data                 Array of pointers to the buffers of data that will\r
                               be transmitted to USB device or received from USB\r
                               device.\r
  @param  DataLength           The size, in bytes, of the data buffer.\r
  @param  Translator           Transaction translator to use.\r
  @param  TransferResult       Variable to receive the transfer result.\r
\r
  @return EFI_UNSUPPORTED      Isochronous transfer is unsupported.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcIsochronousTransfer (\r
  IN     EFI_USB2_HC_PROTOCOL                *This,\r
  IN     UINT8                               DeviceAddress,\r
  IN     UINT8                               EndPointAddress,\r
  IN     UINT8                               DeviceSpeed,\r
  IN     UINTN                               MaximumPacketLength,\r
  IN     UINT8                               DataBuffersNumber,\r
  IN OUT VOID                                *Data[EFI_USB_MAX_ISO_BUFFER_NUM],\r
  IN     UINTN                               DataLength,\r
  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,\r
  OUT    UINT32                              *TransferResult\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  Submits Async isochronous transfer to a target USB device.\r
\r
  @param  This                 This EFI_USB2_HC_PROTOCOL instance.\r
  @param  DeviceAddress        Target device address.\r
  @param  EndPointAddress      End point address with its direction.\r
  @param  DeviceSpeed          Device speed, Low speed device doesn't support this\r
                               type.\r
  @param  MaximumPacketLength  Maximum packet size that the endpoint is capable of\r
                               sending or receiving.\r
  @param  DataBuffersNumber    Number of data buffers prepared for the transfer.\r
  @param  Data                 Array of pointers to the buffers of data that will\r
                               be transmitted to USB device or received from USB\r
                               device.\r
  @param  DataLength           The size, in bytes, of the data buffer.\r
  @param  Translator           Transaction translator to use.\r
  @param  IsochronousCallBack  Function to be called when the transfer complete.\r
  @param  Context              Context passed to the call back function as\r
                               parameter.\r
\r
  @return EFI_UNSUPPORTED      Isochronous transfer isn't supported.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcAsyncIsochronousTransfer (\r
  IN     EFI_USB2_HC_PROTOCOL                *This,\r
  IN     UINT8                               DeviceAddress,\r
  IN     UINT8                               EndPointAddress,\r
  IN     UINT8                               DeviceSpeed,\r
  IN     UINTN                               MaximumPacketLength,\r
  IN     UINT8                               DataBuffersNumber,\r
  IN OUT VOID                                *Data[EFI_USB_MAX_ISO_BUFFER_NUM],\r
  IN     UINTN                               DataLength,\r
  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,\r
  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK     IsochronousCallBack,\r
  IN     VOID                                *Context\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  Entry point for EFI drivers.\r
\r
  @param  ImageHandle       EFI_HANDLE.\r
  @param  SystemTable       EFI_SYSTEM_TABLE.\r
\r
  @retval EFI_SUCCESS       Success.\r
  @retval Others            Fail.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcDriverEntryPoint (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  return EfiLibInstallDriverBindingComponentName2 (\r
           ImageHandle,\r
           SystemTable,\r
           &gXhciDriverBinding,\r
           ImageHandle,\r
           &gXhciComponentName,\r
           &gXhciComponentName2\r
           );\r
}\r
\r
/**\r
  Test to see if this driver supports ControllerHandle. Any\r
  ControllerHandle that has Usb2HcProtocol installed will\r
  be supported.\r
\r
  @param  This                 Protocol instance pointer.\r
  @param  Controller           Handle of device to test.\r
  @param  RemainingDevicePath  Not used.\r
\r
  @return EFI_SUCCESS          This driver supports this device.\r
  @return EFI_UNSUPPORTED      This driver does not support this device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcDriverBindingSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS           Status;\r
  EFI_PCI_IO_PROTOCOL  *PciIo;\r
  USB_CLASSC           UsbClassCReg;\r
\r
  //\r
  // Test whether there is PCI IO Protocol attached on the controller handle.\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiPciIoProtocolGuid,\r
                  (VOID **)&PciIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Status = PciIo->Pci.Read (\r
                        PciIo,\r
                        EfiPciIoWidthUint8,\r
                        PCI_CLASSCODE_OFFSET,\r
                        sizeof (USB_CLASSC) / sizeof (UINT8),\r
                        &UsbClassCReg\r
                        );\r
\r
  if (EFI_ERROR (Status)) {\r
    Status = EFI_UNSUPPORTED;\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Test whether the controller belongs to Xhci type\r
  //\r
  if ((UsbClassCReg.BaseCode != PCI_CLASS_SERIAL) ||\r
      (UsbClassCReg.SubClassCode != PCI_CLASS_SERIAL_USB) ||\r
      (UsbClassCReg.ProgInterface != PCI_IF_XHCI))\r
  {\r
    Status = EFI_UNSUPPORTED;\r
  }\r
\r
ON_EXIT:\r
  gBS->CloseProtocol (\r
         Controller,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         Controller\r
         );\r
\r
  return Status;\r
}\r
\r
/**\r
  Create and initialize a USB_XHCI_INSTANCE structure.\r
\r
  @param  PciIo                  The PciIo on this device.\r
  @param  DevicePath             The device path of host controller.\r
  @param  OriginalPciAttributes  Original PCI attributes.\r
\r
  @return The allocated and initialized USB_XHCI_INSTANCE structure if created,\r
          otherwise NULL.\r
\r
**/\r
USB_XHCI_INSTANCE *\r
XhcCreateUsbHc (\r
  IN EFI_PCI_IO_PROTOCOL       *PciIo,\r
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath,\r
  IN UINT64                    OriginalPciAttributes\r
  )\r
{\r
  USB_XHCI_INSTANCE  *Xhc;\r
  EFI_STATUS         Status;\r
  UINT32             PageSize;\r
  UINT16             ExtCapReg;\r
  UINT8              ReleaseNumber;\r
\r
  Xhc = AllocateZeroPool (sizeof (USB_XHCI_INSTANCE));\r
\r
  if (Xhc == NULL) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Initialize private data structure\r
  //\r
  Xhc->Signature             = XHCI_INSTANCE_SIG;\r
  Xhc->PciIo                 = PciIo;\r
  Xhc->DevicePath            = DevicePath;\r
  Xhc->OriginalPciAttributes = OriginalPciAttributes;\r
  CopyMem (&Xhc->Usb2Hc, &gXhciUsb2HcTemplate, sizeof (EFI_USB2_HC_PROTOCOL));\r
\r
  Status = PciIo->Pci.Read (\r
                        PciIo,\r
                        EfiPciIoWidthUint8,\r
                        XHC_PCI_SBRN_OFFSET,\r
                        1,\r
                        &ReleaseNumber\r
                        );\r
\r
  if (!EFI_ERROR (Status)) {\r
    Xhc->Usb2Hc.MajorRevision = (ReleaseNumber & 0xF0) >> 4;\r
    Xhc->Usb2Hc.MinorRevision = (ReleaseNumber & 0x0F);\r
  }\r
\r
  InitializeListHead (&Xhc->AsyncIntTransfers);\r
\r
  //\r
  // Be caution that the Offset passed to XhcReadCapReg() should be Dword align\r
  //\r
  Xhc->CapLength        = XhcReadCapReg8 (Xhc, XHC_CAPLENGTH_OFFSET);\r
  Xhc->HcSParams1.Dword = XhcReadCapReg (Xhc, XHC_HCSPARAMS1_OFFSET);\r
  Xhc->HcSParams2.Dword = XhcReadCapReg (Xhc, XHC_HCSPARAMS2_OFFSET);\r
  Xhc->HcCParams.Dword  = XhcReadCapReg (Xhc, XHC_HCCPARAMS_OFFSET);\r
  Xhc->DBOff            = XhcReadCapReg (Xhc, XHC_DBOFF_OFFSET);\r
  Xhc->RTSOff           = XhcReadCapReg (Xhc, XHC_RTSOFF_OFFSET);\r
\r
  //\r
  // This PageSize field defines the page size supported by the xHC implementation.\r
  // This xHC supports a page size of 2^(n+12) if bit n is Set. For example,\r
  // if bit 0 is Set, the xHC supports 4k byte page sizes.\r
  //\r
  PageSize      = XhcReadOpReg (Xhc, XHC_PAGESIZE_OFFSET) & XHC_PAGESIZE_MASK;\r
  Xhc->PageSize = 1 << (HighBitSet32 (PageSize) + 12);\r
\r
  ExtCapReg              = (UINT16)(Xhc->HcCParams.Data.ExtCapReg);\r
  Xhc->ExtCapRegBase     = ExtCapReg << 2;\r
  Xhc->UsbLegSupOffset   = XhcGetCapabilityAddr (Xhc, XHC_CAP_USB_LEGACY);\r
  Xhc->DebugCapSupOffset = XhcGetCapabilityAddr (Xhc, XHC_CAP_USB_DEBUG);\r
\r
  DEBUG ((DEBUG_INFO, "XhcCreateUsb3Hc: Capability length 0x%x\n", Xhc->CapLength));\r
  DEBUG ((DEBUG_INFO, "XhcCreateUsb3Hc: HcSParams1 0x%x\n", Xhc->HcSParams1));\r
  DEBUG ((DEBUG_INFO, "XhcCreateUsb3Hc: HcSParams2 0x%x\n", Xhc->HcSParams2));\r
  DEBUG ((DEBUG_INFO, "XhcCreateUsb3Hc: HcCParams 0x%x\n", Xhc->HcCParams));\r
  DEBUG ((DEBUG_INFO, "XhcCreateUsb3Hc: DBOff 0x%x\n", Xhc->DBOff));\r
  DEBUG ((DEBUG_INFO, "XhcCreateUsb3Hc: RTSOff 0x%x\n", Xhc->RTSOff));\r
  DEBUG ((DEBUG_INFO, "XhcCreateUsb3Hc: UsbLegSupOffset 0x%x\n", Xhc->UsbLegSupOffset));\r
  DEBUG ((DEBUG_INFO, "XhcCreateUsb3Hc: DebugCapSupOffset 0x%x\n", Xhc->DebugCapSupOffset));\r
\r
  //\r
  // Create AsyncRequest Polling Timer\r
  //\r
  Status = gBS->CreateEvent (\r
                  EVT_TIMER | EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  XhcMonitorAsyncRequests,\r
                  Xhc,\r
                  &Xhc->PollTimer\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  return Xhc;\r
\r
ON_ERROR:\r
  FreePool (Xhc);\r
  return NULL;\r
}\r
\r
/**\r
  One notified function to stop the Host Controller when gBS->ExitBootServices() called.\r
\r
  @param  Event                   Pointer to this event\r
  @param  Context                 Event handler private data\r
\r
**/\r
VOID\r
EFIAPI\r
XhcExitBootService (\r
  EFI_EVENT  Event,\r
  VOID       *Context\r
  )\r
\r
{\r
  USB_XHCI_INSTANCE    *Xhc;\r
  EFI_PCI_IO_PROTOCOL  *PciIo;\r
\r
  Xhc   = (USB_XHCI_INSTANCE *)Context;\r
  PciIo = Xhc->PciIo;\r
\r
  //\r
  // Stop AsyncRequest Polling timer then stop the XHCI driver\r
  // and uninstall the XHCI protocl.\r
  //\r
  gBS->SetTimer (Xhc->PollTimer, TimerCancel, 0);\r
  XhcHaltHC (Xhc, XHC_GENERIC_TIMEOUT);\r
\r
  if (Xhc->PollTimer != NULL) {\r
    gBS->CloseEvent (Xhc->PollTimer);\r
  }\r
\r
  XhcClearBiosOwnership (Xhc);\r
\r
  //\r
  // Restore original PCI attributes\r
  //\r
  PciIo->Attributes (\r
           PciIo,\r
           EfiPciIoAttributeOperationSet,\r
           Xhc->OriginalPciAttributes,\r
           NULL\r
           );\r
}\r
\r
/**\r
  Starting the Usb XHCI Driver.\r
\r
  @param  This                 Protocol instance pointer.\r
  @param  Controller           Handle of device to test.\r
  @param  RemainingDevicePath  Not used.\r
\r
  @return EFI_SUCCESS          supports this device.\r
  @return EFI_UNSUPPORTED      do not support this device.\r
  @return EFI_DEVICE_ERROR     cannot be started due to device Error.\r
  @return EFI_OUT_OF_RESOURCES cannot allocate resources.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcDriverBindingStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_PCI_IO_PROTOCOL       *PciIo;\r
  UINT64                    Supports;\r
  UINT64                    OriginalPciAttributes;\r
  BOOLEAN                   PciAttributesSaved;\r
  USB_XHCI_INSTANCE         *Xhc;\r
  EFI_DEVICE_PATH_PROTOCOL  *HcDevicePath;\r
\r
  //\r
  // Open the PciIo Protocol, then enable the USB host controller\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiPciIoProtocolGuid,\r
                  (VOID **)&PciIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Open Device Path Protocol for on USB host controller\r
  //\r
  HcDevicePath = NULL;\r
  Status       = gBS->OpenProtocol (\r
                        Controller,\r
                        &gEfiDevicePathProtocolGuid,\r
                        (VOID **)&HcDevicePath,\r
                        This->DriverBindingHandle,\r
                        Controller,\r
                        EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                        );\r
\r
  PciAttributesSaved = FALSE;\r
  //\r
  // Save original PCI attributes\r
  //\r
  Status = PciIo->Attributes (\r
                    PciIo,\r
                    EfiPciIoAttributeOperationGet,\r
                    0,\r
                    &OriginalPciAttributes\r
                    );\r
\r
  if (EFI_ERROR (Status)) {\r
    goto CLOSE_PCIIO;\r
  }\r
\r
  PciAttributesSaved = TRUE;\r
\r
  Status = PciIo->Attributes (\r
                    PciIo,\r
                    EfiPciIoAttributeOperationSupported,\r
                    0,\r
                    &Supports\r
                    );\r
  if (!EFI_ERROR (Status)) {\r
    Supports &= (UINT64)EFI_PCI_DEVICE_ENABLE;\r
    Status    = PciIo->Attributes (\r
                         PciIo,\r
                         EfiPciIoAttributeOperationEnable,\r
                         Supports,\r
                         NULL\r
                         );\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "XhcDriverBindingStart: failed to enable controller\n"));\r
    goto CLOSE_PCIIO;\r
  }\r
\r
  //\r
  // Create then install USB2_HC_PROTOCOL\r
  //\r
  Xhc = XhcCreateUsbHc (PciIo, HcDevicePath, OriginalPciAttributes);\r
\r
  if (Xhc == NULL) {\r
    DEBUG ((DEBUG_ERROR, "XhcDriverBindingStart: failed to create USB2_HC\n"));\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Enable 64-bit DMA support in the PCI layer if this controller\r
  // supports it.\r
  //\r
  if (Xhc->HcCParams.Data.Ac64 != 0) {\r
    Status = PciIo->Attributes (\r
                      PciIo,\r
                      EfiPciIoAttributeOperationEnable,\r
                      EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE,\r
                      NULL\r
                      );\r
    if (!EFI_ERROR (Status)) {\r
      Xhc->Support64BitDma = TRUE;\r
    } else {\r
      DEBUG ((\r
        DEBUG_WARN,\r
        "%a: failed to enable 64-bit DMA on 64-bit capable controller @ %p (%r)\n",\r
        __FUNCTION__,\r
        Controller,\r
        Status\r
        ));\r
    }\r
  }\r
\r
  XhcSetBiosOwnership (Xhc);\r
\r
  XhcResetHC (Xhc, XHC_RESET_TIMEOUT);\r
  ASSERT (XhcIsHalt (Xhc));\r
\r
  //\r
  // After Chip Hardware Reset wait until the Controller Not Ready (CNR) flag\r
  // in the USBSTS is '0' before writing any xHC Operational or Runtime registers.\r
  //\r
  ASSERT (!(XHC_REG_BIT_IS_SET (Xhc, XHC_USBSTS_OFFSET, XHC_USBSTS_CNR)));\r
\r
  //\r
  // Initialize the schedule\r
  //\r
  XhcInitSched (Xhc);\r
\r
  //\r
  // Start the Host Controller\r
  //\r
  XhcRunHC (Xhc, XHC_GENERIC_TIMEOUT);\r
\r
  //\r
  // Start the asynchronous interrupt monitor\r
  //\r
  Status = gBS->SetTimer (Xhc->PollTimer, TimerPeriodic, XHC_ASYNC_TIMER_INTERVAL);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "XhcDriverBindingStart: failed to start async interrupt monitor\n"));\r
    XhcHaltHC (Xhc, XHC_GENERIC_TIMEOUT);\r
    goto FREE_POOL;\r
  }\r
\r
  //\r
  // Create event to stop the HC when exit boot service.\r
  //\r
  Status = gBS->CreateEventEx (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  XhcExitBootService,\r
                  Xhc,\r
                  &gEfiEventExitBootServicesGuid,\r
                  &Xhc->ExitBootServiceEvent\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto FREE_POOL;\r
  }\r
\r
  //\r
  // Install the component name protocol, don't fail the start\r
  // because of something for display.\r
  //\r
  AddUnicodeString2 (\r
    "eng",\r
    gXhciComponentName.SupportedLanguages,\r
    &Xhc->ControllerNameTable,\r
    L"eXtensible Host Controller (USB 3.0)",\r
    TRUE\r
    );\r
  AddUnicodeString2 (\r
    "en",\r
    gXhciComponentName2.SupportedLanguages,\r
    &Xhc->ControllerNameTable,\r
    L"eXtensible Host Controller (USB 3.0)",\r
    FALSE\r
    );\r
\r
  Status = gBS->InstallProtocolInterface (\r
                  &Controller,\r
                  &gEfiUsb2HcProtocolGuid,\r
                  EFI_NATIVE_INTERFACE,\r
                  &Xhc->Usb2Hc\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "XhcDriverBindingStart: failed to install USB2_HC Protocol\n"));\r
    goto FREE_POOL;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "XhcDriverBindingStart: XHCI started for controller @ %x\n", Controller));\r
  return EFI_SUCCESS;\r
\r
FREE_POOL:\r
  gBS->CloseEvent (Xhc->PollTimer);\r
  XhcFreeSched (Xhc);\r
  FreePool (Xhc);\r
\r
CLOSE_PCIIO:\r
  if (PciAttributesSaved) {\r
    //\r
    // Restore original PCI attributes\r
    //\r
    PciIo->Attributes (\r
             PciIo,\r
             EfiPciIoAttributeOperationSet,\r
             OriginalPciAttributes,\r
             NULL\r
             );\r
  }\r
\r
  gBS->CloseProtocol (\r
         Controller,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         Controller\r
         );\r
\r
  return Status;\r
}\r
\r
/**\r
  Stop this driver on ControllerHandle. Support stopping any child handles\r
  created by this driver.\r
\r
  @param  This                 Protocol instance pointer.\r
  @param  Controller           Handle of device to stop driver on.\r
  @param  NumberOfChildren     Number of Children in the ChildHandleBuffer.\r
  @param  ChildHandleBuffer    List of handles for the children we need to stop.\r
\r
  @return EFI_SUCCESS          Success.\r
  @return EFI_DEVICE_ERROR     Fail.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
XhcDriverBindingStop (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   Controller,\r
  IN UINTN                        NumberOfChildren,\r
  IN EFI_HANDLE                   *ChildHandleBuffer\r
  )\r
{\r
  EFI_STATUS            Status;\r
  EFI_USB2_HC_PROTOCOL  *Usb2Hc;\r
  EFI_PCI_IO_PROTOCOL   *PciIo;\r
  USB_XHCI_INSTANCE     *Xhc;\r
  UINT8                 Index;\r
\r
  //\r
  // Test whether the Controller handler passed in is a valid\r
  // Usb controller handle that should be supported, if not,\r
  // return the error status directly\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiUsb2HcProtocolGuid,\r
                  (VOID **)&Usb2Hc,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = gBS->UninstallProtocolInterface (\r
                  Controller,\r
                  &gEfiUsb2HcProtocolGuid,\r
                  Usb2Hc\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Xhc   = XHC_FROM_THIS (Usb2Hc);\r
  PciIo = Xhc->PciIo;\r
\r
  //\r
  // Stop AsyncRequest Polling timer then stop the XHCI driver\r
  // and uninstall the XHCI protocl.\r
  //\r
  gBS->SetTimer (Xhc->PollTimer, TimerCancel, 0);\r
\r
  //\r
  // Disable the device slots occupied by these devices on its downstream ports.\r
  // Entry 0 is reserved.\r
  //\r
  for (Index = 0; Index < 255; Index++) {\r
    if (!Xhc->UsbDevContext[Index + 1].Enabled ||\r
        (Xhc->UsbDevContext[Index + 1].SlotId == 0))\r
    {\r
      continue;\r
    }\r
\r
    if (Xhc->HcCParams.Data.Csz == 0) {\r
      XhcDisableSlotCmd (Xhc, Xhc->UsbDevContext[Index + 1].SlotId);\r
    } else {\r
      XhcDisableSlotCmd64 (Xhc, Xhc->UsbDevContext[Index + 1].SlotId);\r
    }\r
  }\r
\r
  if (Xhc->PollTimer != NULL) {\r
    gBS->CloseEvent (Xhc->PollTimer);\r
  }\r
\r
  if (Xhc->ExitBootServiceEvent != NULL) {\r
    gBS->CloseEvent (Xhc->ExitBootServiceEvent);\r
  }\r
\r
  XhcHaltHC (Xhc, XHC_GENERIC_TIMEOUT);\r
  XhcClearBiosOwnership (Xhc);\r
  XhciDelAllAsyncIntTransfers (Xhc);\r
  XhcFreeSched (Xhc);\r
\r
  if (Xhc->ControllerNameTable) {\r
    FreeUnicodeStringTable (Xhc->ControllerNameTable);\r
  }\r
\r
  //\r
  // Restore original PCI attributes\r
  //\r
  PciIo->Attributes (\r
           PciIo,\r
           EfiPciIoAttributeOperationSet,\r
           Xhc->OriginalPciAttributes,\r
           NULL\r
           );\r
\r
  gBS->CloseProtocol (\r
         Controller,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         Controller\r
         );\r
\r
  FreePool (Xhc);\r
\r
  return EFI_SUCCESS;\r
}\r