UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm

[mirror_edk2.git] / MdeModulePkg / Bus / Pci / EhciPei / EhciSched.c

/** @file\r
PEIM to produce gPeiUsb2HostControllerPpiGuid based on gPeiUsbControllerPpiGuid\r
which is used to enable recovery function from USB Drivers.\r
\r
Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>\r
Copyright (c) Microsoft Corporation.<BR>\r
\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "EhcPeim.h"\r
\r
/**\r
  Create helper QTD/QH for the EHCI device.\r
\r
  @param  Ehc         The EHCI device.\r
\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource for helper QTD/QH.\r
  @retval EFI_SUCCESS           Helper QH/QTD are created.\r
\r
**/\r
EFI_STATUS\r
EhcCreateHelpQ (\r
  IN PEI_USB2_HC_DEV  *Ehc\r
  )\r
{\r
  USB_ENDPOINT  Ep;\r
  PEI_EHC_QH    *Qh;\r
  QH_HW         *QhHw;\r
  PEI_EHC_QTD   *Qtd;\r
\r
  //\r
  // Create an inactive Qtd to terminate the short packet read.\r
  //\r
  Qtd = EhcCreateQtd (Ehc, NULL, 0, QTD_PID_INPUT, 0, 64);\r
\r
  if (Qtd == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Qtd->QtdHw.Status  = QTD_STAT_HALTED;\r
  Ehc->ShortReadStop = Qtd;\r
\r
  //\r
  // Create a QH to act as the EHC reclamation header.\r
  // Set the header to loopback to itself.\r
  //\r
  Ep.DevAddr   = 0;\r
  Ep.EpAddr    = 1;\r
  Ep.Direction = EfiUsbDataIn;\r
  Ep.DevSpeed  = EFI_USB_SPEED_HIGH;\r
  Ep.MaxPacket = 64;\r
  Ep.HubAddr   = 0;\r
  Ep.HubPort   = 0;\r
  Ep.Toggle    = 0;\r
  Ep.Type      = EHC_BULK_TRANSFER;\r
  Ep.PollRate  = 1;\r
\r
  Qh = EhcCreateQh (Ehc, &Ep);\r
\r
  if (Qh == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  QhHw              = &Qh->QhHw;\r
  QhHw->HorizonLink = QH_LINK (QhHw, EHC_TYPE_QH, FALSE);\r
  QhHw->Status      = QTD_STAT_HALTED;\r
  QhHw->ReclaimHead = 1;\r
  Ehc->ReclaimHead  = Qh;\r
\r
  //\r
  // Create a dummy QH to act as the terminator for periodical schedule\r
  //\r
  Ep.EpAddr = 2;\r
  Ep.Type   = EHC_INT_TRANSFER_SYNC;\r
\r
  Qh = EhcCreateQh (Ehc, &Ep);\r
\r
  if (Qh == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Qh->QhHw.Status = QTD_STAT_HALTED;\r
  Ehc->PeriodOne  = Qh;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Initialize the schedule data structure such as frame list.\r
\r
  @param  Ehc                   The EHCI device to init schedule data for.\r
\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource to init schedule data.\r
  @retval EFI_SUCCESS           The schedule data is initialized.\r
\r
**/\r
EFI_STATUS\r
EhcInitSched (\r
  IN PEI_USB2_HC_DEV  *Ehc\r
  )\r
{\r
  VOID                  *Buf;\r
  EFI_PHYSICAL_ADDRESS  PhyAddr;\r
  VOID                  *Map;\r
  UINTN                 Index;\r
  UINT32                *Desc;\r
  EFI_STATUS            Status;\r
  EFI_PHYSICAL_ADDRESS  PciAddr;\r
\r
  //\r
  // First initialize the periodical schedule data:\r
  // 1. Allocate and map the memory for the frame list\r
  // 2. Create the help QTD/QH\r
  // 3. Initialize the frame entries\r
  // 4. Set the frame list register\r
  //\r
  //\r
  // The Frame List ocupies 4K bytes,\r
  // and must be aligned on 4-Kbyte boundaries.\r
  //\r
  Status = IoMmuAllocateBuffer (\r
             Ehc->IoMmu,\r
             1,\r
             &Buf,\r
             &PhyAddr,\r
             &Map\r
             );\r
\r
  if (EFI_ERROR (Status) || (Buf == NULL)) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Ehc->PeriodFrame    = Buf;\r
  Ehc->PeriodFrameMap = Map;\r
  Ehc->High32bitAddr  = EHC_HIGH_32BIT (PhyAddr);\r
\r
  //\r
  // Init memory pool management then create the helper\r
  // QTD/QH. If failed, previously allocated resources\r
  // will be freed by EhcFreeSched\r
  //\r
  Ehc->MemPool = UsbHcInitMemPool (\r
                   Ehc,\r
                   EHC_BIT_IS_SET (Ehc->HcCapParams, HCCP_64BIT),\r
                   Ehc->High32bitAddr\r
                   );\r
\r
  if (Ehc->MemPool == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Status = EhcCreateHelpQ (Ehc);\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Initialize the frame list entries then set the registers\r
  //\r
  Desc    = (UINT32 *)Ehc->PeriodFrame;\r
  PciAddr = UsbHcGetPciAddressForHostMem (Ehc->MemPool, Ehc->PeriodOne, sizeof (PEI_EHC_QH));\r
  for (Index = 0; Index < EHC_FRAME_LEN; Index++) {\r
    Desc[Index] = QH_LINK (PciAddr, EHC_TYPE_QH, FALSE);\r
  }\r
\r
  EhcWriteOpReg (Ehc, EHC_FRAME_BASE_OFFSET, EHC_LOW_32BIT (PhyAddr));\r
\r
  //\r
  // Second initialize the asynchronous schedule:\r
  // Only need to set the AsynListAddr register to\r
  // the reclamation header\r
  //\r
  PciAddr = UsbHcGetPciAddressForHostMem (Ehc->MemPool, Ehc->ReclaimHead, sizeof (PEI_EHC_QH));\r
  EhcWriteOpReg (Ehc, EHC_ASYNC_HEAD_OFFSET, EHC_LOW_32BIT (PciAddr));\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Free the schedule data. It may be partially initialized.\r
\r
  @param  Ehc   The EHCI device.\r
\r
**/\r
VOID\r
EhcFreeSched (\r
  IN PEI_USB2_HC_DEV  *Ehc\r
  )\r
{\r
  EhcWriteOpReg (Ehc, EHC_FRAME_BASE_OFFSET, 0);\r
  EhcWriteOpReg (Ehc, EHC_ASYNC_HEAD_OFFSET, 0);\r
\r
  if (Ehc->PeriodOne != NULL) {\r
    UsbHcFreeMem (Ehc, Ehc->MemPool, Ehc->PeriodOne, sizeof (PEI_EHC_QH));\r
    Ehc->PeriodOne = NULL;\r
  }\r
\r
  if (Ehc->ReclaimHead != NULL) {\r
    UsbHcFreeMem (Ehc, Ehc->MemPool, Ehc->ReclaimHead, sizeof (PEI_EHC_QH));\r
    Ehc->ReclaimHead = NULL;\r
  }\r
\r
  if (Ehc->ShortReadStop != NULL) {\r
    UsbHcFreeMem (Ehc, Ehc->MemPool, Ehc->ShortReadStop, sizeof (PEI_EHC_QTD));\r
    Ehc->ShortReadStop = NULL;\r
  }\r
\r
  if (Ehc->MemPool != NULL) {\r
    UsbHcFreeMemPool (Ehc, Ehc->MemPool);\r
    Ehc->MemPool = NULL;\r
  }\r
\r
  if (Ehc->PeriodFrame != NULL) {\r
    IoMmuFreeBuffer (Ehc->IoMmu, 1, Ehc->PeriodFrame, Ehc->PeriodFrameMap);\r
    Ehc->PeriodFrame = NULL;\r
  }\r
}\r
\r
/**\r
  Link the queue head to the asynchronous schedule list.\r
  UEFI only supports one CTRL/BULK transfer at a time\r
  due to its interfaces. This simplifies the AsynList\r
  management: A reclamation header is always linked to\r
  the AsyncListAddr, the only active QH is appended to it.\r
\r
  @param  Ehc   The EHCI device.\r
  @param  Qh    The queue head to link.\r
\r
**/\r
VOID\r
EhcLinkQhToAsync (\r
  IN PEI_USB2_HC_DEV  *Ehc,\r
  IN PEI_EHC_QH       *Qh\r
  )\r
{\r
  PEI_EHC_QH  *Head;\r
\r
  //\r
  // Append the queue head after the reclaim header, then\r
  // fix the hardware visiable parts (EHCI R1.0 page 72).\r
  // ReclaimHead is always linked to the EHCI's AsynListAddr.\r
  //\r
  Head = Ehc->ReclaimHead;\r
\r
  Qh->NextQh   = Head->NextQh;\r
  Head->NextQh = Qh;\r
\r
  Qh->QhHw.HorizonLink   = QH_LINK (Head, EHC_TYPE_QH, FALSE);\r
  Head->QhHw.HorizonLink = QH_LINK (Qh, EHC_TYPE_QH, FALSE);\r
}\r
\r
/**\r
  Unlink a queue head from the asynchronous schedule list.\r
  Need to synchronize with hardware.\r
\r
  @param  Ehc   The EHCI device.\r
  @param  Qh    The queue head to unlink.\r
\r
**/\r
VOID\r
EhcUnlinkQhFromAsync (\r
  IN PEI_USB2_HC_DEV  *Ehc,\r
  IN PEI_EHC_QH       *Qh\r
  )\r
{\r
  PEI_EHC_QH  *Head;\r
\r
  ASSERT (Ehc->ReclaimHead->NextQh == Qh);\r
\r
  //\r
  // Remove the QH from reclamation head, then update the hardware\r
  // visiable part: Only need to loopback the ReclaimHead. The Qh\r
  // is pointing to ReclaimHead (which is staill in the list).\r
  //\r
  Head = Ehc->ReclaimHead;\r
\r
  Head->NextQh = Qh->NextQh;\r
  Qh->NextQh   = NULL;\r
\r
  Head->QhHw.HorizonLink = QH_LINK (Head, EHC_TYPE_QH, FALSE);\r
\r
  //\r
  // Set and wait the door bell to synchronize with the hardware\r
  //\r
  EhcSetAndWaitDoorBell (Ehc, EHC_GENERIC_TIMEOUT);\r
\r
  return;\r
}\r
\r
/**\r
  Check the URB's execution result and update the URB's\r
  result accordingly.\r
\r
  @param Ehc   The EHCI device.\r
  @param Urb   The URB to check result.\r
\r
  @retval TRUE    URB transfer is finialized.\r
  @retval FALSE   URB transfer is not finialized.\r
\r
**/\r
BOOLEAN\r
EhcCheckUrbResult (\r
  IN  PEI_USB2_HC_DEV  *Ehc,\r
  IN  PEI_URB          *Urb\r
  )\r
{\r
  EFI_LIST_ENTRY  *Entry;\r
  PEI_EHC_QTD     *Qtd;\r
  QTD_HW          *QtdHw;\r
  UINT8           State;\r
  BOOLEAN         Finished;\r
\r
  ASSERT ((Ehc != NULL) && (Urb != NULL) && (Urb->Qh != NULL));\r
\r
  Finished       = TRUE;\r
  Urb->Completed = 0;\r
\r
  Urb->Result = EFI_USB_NOERROR;\r
\r
  if (EhcIsHalt (Ehc) || EhcIsSysError (Ehc)) {\r
    Urb->Result |= EFI_USB_ERR_SYSTEM;\r
    goto ON_EXIT;\r
  }\r
\r
  BASE_LIST_FOR_EACH (Entry, &Urb->Qh->Qtds) {\r
    Qtd   = EFI_LIST_CONTAINER (Entry, PEI_EHC_QTD, QtdList);\r
    QtdHw = &Qtd->QtdHw;\r
    State = (UINT8)QtdHw->Status;\r
\r
    if (EHC_BIT_IS_SET (State, QTD_STAT_HALTED)) {\r
      //\r
      // EHCI will halt the queue head when met some error.\r
      // If it is halted, the result of URB is finialized.\r
      //\r
      if ((State & QTD_STAT_ERR_MASK) == 0) {\r
        Urb->Result |= EFI_USB_ERR_STALL;\r
      }\r
\r
      if (EHC_BIT_IS_SET (State, QTD_STAT_BABBLE_ERR)) {\r
        Urb->Result |= EFI_USB_ERR_BABBLE;\r
      }\r
\r
      if (EHC_BIT_IS_SET (State, QTD_STAT_BUFF_ERR)) {\r
        Urb->Result |= EFI_USB_ERR_BUFFER;\r
      }\r
\r
      if (EHC_BIT_IS_SET (State, QTD_STAT_TRANS_ERR) && (QtdHw->ErrCnt == 0)) {\r
        Urb->Result |= EFI_USB_ERR_TIMEOUT;\r
      }\r
\r
      Finished = TRUE;\r
      goto ON_EXIT;\r
    } else if (EHC_BIT_IS_SET (State, QTD_STAT_ACTIVE)) {\r
      //\r
      // The QTD is still active, no need to check furthur.\r
      //\r
      Urb->Result |= EFI_USB_ERR_NOTEXECUTE;\r
\r
      Finished = FALSE;\r
      goto ON_EXIT;\r
    } else {\r
      //\r
      // This QTD is finished OK or met short packet read. Update the\r
      // transfer length if it isn't a setup.\r
      //\r
      if (QtdHw->Pid != QTD_PID_SETUP) {\r
        Urb->Completed += Qtd->DataLen - QtdHw->TotalBytes;\r
      }\r
\r
      if ((QtdHw->TotalBytes != 0) && (QtdHw->Pid == QTD_PID_INPUT)) {\r
        // EHC_DUMP_QH ((Urb->Qh, "Short packet read", FALSE));\r
\r
        //\r
        // Short packet read condition. If it isn't a setup transfer,\r
        // no need to check furthur: the queue head will halt at the\r
        // ShortReadStop. If it is a setup transfer, need to check the\r
        // Status Stage of the setup transfer to get the finial result\r
        //\r
        if (QtdHw->AltNext == QTD_LINK (Ehc->ShortReadStop, FALSE)) {\r
          Finished = TRUE;\r
          goto ON_EXIT;\r
        }\r
      }\r
    }\r
  }\r
\r
ON_EXIT:\r
  //\r
  // Return the data toggle set by EHCI hardware, bulk and interrupt\r
  // transfer will use this to initialize the next transaction. For\r
  // Control transfer, it always start a new data toggle sequence for\r
  // new transfer.\r
  //\r
  // NOTICE: don't move DT update before the loop, otherwise there is\r
  // a race condition that DT is wrong.\r
  //\r
  Urb->DataToggle = (UINT8)Urb->Qh->QhHw.DataToggle;\r
\r
  return Finished;\r
}\r
\r
/**\r
  Execute the transfer by polling the URB. This is a synchronous operation.\r
\r
  @param  Ehc               The EHCI device.\r
  @param  Urb               The URB to execute.\r
  @param  TimeOut           The time to wait before abort, in millisecond.\r
\r
  @retval EFI_DEVICE_ERROR  The transfer failed due to transfer error.\r
  @retval EFI_TIMEOUT       The transfer failed due to time out.\r
  @retval EFI_SUCCESS       The transfer finished OK.\r
\r
**/\r
EFI_STATUS\r
EhcExecTransfer (\r
  IN  PEI_USB2_HC_DEV  *Ehc,\r
  IN  PEI_URB          *Urb,\r
  IN  UINTN            TimeOut\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Index;\r
  UINTN       Loop;\r
  BOOLEAN     Finished;\r
  BOOLEAN     InfiniteLoop;\r
\r
  Status       = EFI_SUCCESS;\r
  Loop         = TimeOut * EHC_1_MILLISECOND;\r
  Finished     = FALSE;\r
  InfiniteLoop = FALSE;\r
\r
  //\r
  // If Timeout is 0, then the caller must wait for the function to be completed\r
  // until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.\r
  //\r
  if (TimeOut == 0) {\r
    InfiniteLoop = TRUE;\r
  }\r
\r
  for (Index = 0; InfiniteLoop || (Index < Loop); Index++) {\r
    Finished = EhcCheckUrbResult (Ehc, Urb);\r
\r
    if (Finished) {\r
      break;\r
    }\r
\r
    MicroSecondDelay (EHC_1_MICROSECOND);\r
  }\r
\r
  if (!Finished) {\r
    Status = EFI_TIMEOUT;\r
  } else if (Urb->Result != EFI_USB_NOERROR) {\r
    Status = EFI_DEVICE_ERROR;\r
  }\r
\r
  return Status;\r
}\r