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

[mirror_edk2.git] / MdeModulePkg / Bus / Pci / EhciPei / EhciUrb.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
  Delete a single asynchronous interrupt transfer for\r
  the device and endpoint.\r
\r
  @param  Ehc         The EHCI device.\r
  @param  Data        Current data not associated with a QTD.\r
  @param  DataLen     The length of the data.\r
  @param  PktId       Packet ID to use in the QTD.\r
  @param  Toggle      Data toggle to use in the QTD.\r
  @param  MaxPacket   Maximu packet length of the endpoint.\r
\r
  @retval the pointer to the created QTD or NULL if failed to create one.\r
\r
**/\r
PEI_EHC_QTD *\r
EhcCreateQtd (\r
  IN PEI_USB2_HC_DEV  *Ehc,\r
  IN UINT8            *Data,\r
  IN UINTN            DataLen,\r
  IN UINT8            PktId,\r
  IN UINT8            Toggle,\r
  IN UINTN            MaxPacket\r
  )\r
{\r
  PEI_EHC_QTD  *Qtd;\r
  QTD_HW       *QtdHw;\r
  UINTN        Index;\r
  UINTN        Len;\r
  UINTN        ThisBufLen;\r
\r
  ASSERT (Ehc != NULL);\r
\r
  Qtd = UsbHcAllocateMem (Ehc, Ehc->MemPool, sizeof (PEI_EHC_QTD));\r
\r
  if (Qtd == NULL) {\r
    return NULL;\r
  }\r
\r
  Qtd->Signature = EHC_QTD_SIG;\r
  Qtd->Data      = Data;\r
  Qtd->DataLen   = 0;\r
\r
  InitializeListHead (&Qtd->QtdList);\r
\r
  QtdHw             = &Qtd->QtdHw;\r
  QtdHw->NextQtd    = QTD_LINK (NULL, TRUE);\r
  QtdHw->AltNext    = QTD_LINK (NULL, TRUE);\r
  QtdHw->Status     = QTD_STAT_ACTIVE;\r
  QtdHw->Pid        = PktId;\r
  QtdHw->ErrCnt     = QTD_MAX_ERR;\r
  QtdHw->Ioc        = 0;\r
  QtdHw->TotalBytes = 0;\r
  QtdHw->DataToggle = Toggle;\r
\r
  //\r
  // Fill in the buffer points\r
  //\r
  if (Data != NULL) {\r
    Len = 0;\r
\r
    for (Index = 0; Index <= QTD_MAX_BUFFER; Index++) {\r
      //\r
      // Set the buffer point (Check page 41 EHCI Spec 1.0). No need to\r
      // compute the offset and clear Reserved fields. This is already\r
      // done in the data point.\r
      //\r
      QtdHw->Page[Index]     = EHC_LOW_32BIT (Data);\r
      QtdHw->PageHigh[Index] = EHC_HIGH_32BIT (Data);\r
\r
      ThisBufLen = QTD_BUF_LEN - (EHC_LOW_32BIT (Data) & QTD_BUF_MASK);\r
\r
      if (Len + ThisBufLen >= DataLen) {\r
        Len = DataLen;\r
        break;\r
      }\r
\r
      Len  += ThisBufLen;\r
      Data += ThisBufLen;\r
    }\r
\r
    //\r
    // Need to fix the last pointer if the Qtd can't hold all the\r
    // user's data to make sure that the length is in the unit of\r
    // max packets. If it can hold all the data, there is no such\r
    // need.\r
    //\r
    if (Len < DataLen) {\r
      Len = Len - Len % MaxPacket;\r
    }\r
\r
    QtdHw->TotalBytes = (UINT32)Len;\r
    Qtd->DataLen      = Len;\r
  }\r
\r
  return Qtd;\r
}\r
\r
/**\r
  Initialize the queue head for interrupt transfer,\r
  that is, initialize the following three fields:\r
    1. SplitXState in the Status field.\r
    2. Microframe S-mask.\r
    3. Microframe C-mask.\r
\r
  @param  Ep    The queue head's related endpoint.\r
  @param  QhHw  The queue head to initialize.\r
\r
**/\r
VOID\r
EhcInitIntQh (\r
  IN USB_ENDPOINT  *Ep,\r
  IN QH_HW         *QhHw\r
  )\r
{\r
  //\r
  // Because UEFI interface can't utilitize an endpoint with\r
  // poll rate faster than 1ms, only need to set one bit in\r
  // the queue head. simple. But it may be changed later. If\r
  // sub-1ms interrupt is supported, need to update the S-Mask\r
  // here\r
  //\r
  if (Ep->DevSpeed == EFI_USB_SPEED_HIGH) {\r
    QhHw->SMask = QH_MICROFRAME_0;\r
    return;\r
  }\r
\r
  //\r
  // For low/full speed device, the transfer must go through\r
  // the split transaction. Need to update three fields\r
  // 1. SplitXState in the status\r
  // 2. Microframe S-Mask\r
  // 3. Microframe C-Mask\r
  // UEFI USB doesn't exercise admission control. It simplely\r
  // schedule the high speed transactions in microframe 0, and\r
  // full/low speed transactions at microframe 1. This also\r
  // avoid the use of FSTN.\r
  //\r
  QhHw->SMask = QH_MICROFRAME_1;\r
  QhHw->CMask = QH_MICROFRAME_3 | QH_MICROFRAME_4 | QH_MICROFRAME_5;\r
}\r
\r
/**\r
  Allocate and initialize a EHCI queue head.\r
\r
  @param  Ehci      The EHCI device.\r
  @param  Ep        The endpoint to create queue head for.\r
\r
  @retval the pointer to the created queue head or NULL if failed to create one.\r
\r
**/\r
PEI_EHC_QH *\r
EhcCreateQh (\r
  IN PEI_USB2_HC_DEV  *Ehci,\r
  IN USB_ENDPOINT     *Ep\r
  )\r
{\r
  PEI_EHC_QH  *Qh;\r
  QH_HW       *QhHw;\r
\r
  Qh = UsbHcAllocateMem (Ehci, Ehci->MemPool, sizeof (PEI_EHC_QH));\r
\r
  if (Qh == NULL) {\r
    return NULL;\r
  }\r
\r
  Qh->Signature = EHC_QH_SIG;\r
  Qh->NextQh    = NULL;\r
  Qh->Interval  = Ep->PollRate;\r
\r
  InitializeListHead (&Qh->Qtds);\r
\r
  QhHw               = &Qh->QhHw;\r
  QhHw->HorizonLink  = QH_LINK (NULL, 0, TRUE);\r
  QhHw->DeviceAddr   = Ep->DevAddr;\r
  QhHw->Inactive     = 0;\r
  QhHw->EpNum        = Ep->EpAddr;\r
  QhHw->EpSpeed      = Ep->DevSpeed;\r
  QhHw->DtCtrl       = 0;\r
  QhHw->ReclaimHead  = 0;\r
  QhHw->MaxPacketLen = (UINT32)Ep->MaxPacket;\r
  QhHw->CtrlEp       = 0;\r
  QhHw->NakReload    = QH_NAK_RELOAD;\r
  QhHw->HubAddr      = Ep->HubAddr;\r
  QhHw->PortNum      = Ep->HubPort;\r
  QhHw->Multiplier   = 1;\r
  QhHw->DataToggle   = Ep->Toggle;\r
\r
  if (Ep->DevSpeed != EFI_USB_SPEED_HIGH) {\r
    QhHw->Status |= QTD_STAT_DO_SS;\r
  }\r
\r
  switch (Ep->Type) {\r
    case EHC_CTRL_TRANSFER:\r
      //\r
      // Special initialization for the control transfer:\r
      // 1. Control transfer initialize data toggle from each QTD\r
      // 2. Set the Control Endpoint Flag (C) for low/full speed endpoint.\r
      //\r
      QhHw->DtCtrl = 1;\r
\r
      if (Ep->DevSpeed != EFI_USB_SPEED_HIGH) {\r
        QhHw->CtrlEp = 1;\r
      }\r
\r
      break;\r
\r
    case EHC_INT_TRANSFER_ASYNC:\r
    case EHC_INT_TRANSFER_SYNC:\r
      //\r
      // Special initialization for the interrupt transfer\r
      // to set the S-Mask and C-Mask\r
      //\r
      QhHw->NakReload = 0;\r
      EhcInitIntQh (Ep, QhHw);\r
      break;\r
\r
    case EHC_BULK_TRANSFER:\r
      if ((Ep->DevSpeed == EFI_USB_SPEED_HIGH) && (Ep->Direction == EfiUsbDataOut)) {\r
        QhHw->Status |= QTD_STAT_DO_PING;\r
      }\r
\r
      break;\r
  }\r
\r
  return Qh;\r
}\r
\r
/**\r
  Convert the poll interval from application to that\r
  be used by EHCI interface data structure. Only need\r
  to get the max 2^n that is less than interval. UEFI\r
  can't support high speed endpoint with a interval less\r
  than 8 microframe because interval is specified in\r
  the unit of ms (millisecond).\r
\r
  @param Interval       The interval to convert.\r
\r
  @retval The converted interval.\r
\r
**/\r
UINTN\r
EhcConvertPollRate (\r
  IN  UINTN  Interval\r
  )\r
{\r
  UINTN  BitCount;\r
\r
  if (Interval == 0) {\r
    return 1;\r
  }\r
\r
  //\r
  // Find the index (1 based) of the highest non-zero bit\r
  //\r
  BitCount = 0;\r
\r
  while (Interval != 0) {\r
    Interval >>= 1;\r
    BitCount++;\r
  }\r
\r
  return (UINTN)1 << (BitCount - 1);\r
}\r
\r
/**\r
  Free a list of QTDs.\r
\r
  @param  Ehc         The EHCI device.\r
  @param  Qtds        The list head of the QTD.\r
\r
**/\r
VOID\r
EhcFreeQtds (\r
  IN PEI_USB2_HC_DEV  *Ehc,\r
  IN EFI_LIST_ENTRY   *Qtds\r
  )\r
{\r
  EFI_LIST_ENTRY  *Entry;\r
  EFI_LIST_ENTRY  *Next;\r
  PEI_EHC_QTD     *Qtd;\r
\r
  BASE_LIST_FOR_EACH_SAFE (Entry, Next, Qtds) {\r
    Qtd = EFI_LIST_CONTAINER (Entry, PEI_EHC_QTD, QtdList);\r
\r
    RemoveEntryList (&Qtd->QtdList);\r
    UsbHcFreeMem (Ehc, Ehc->MemPool, Qtd, sizeof (PEI_EHC_QTD));\r
  }\r
}\r
\r
/**\r
  Free an allocated URB. It is possible for it to be partially inited.\r
\r
  @param  Ehc         The EHCI device.\r
  @param  Urb         The URB to free.\r
\r
**/\r
VOID\r
EhcFreeUrb (\r
  IN PEI_USB2_HC_DEV  *Ehc,\r
  IN PEI_URB          *Urb\r
  )\r
{\r
  if (Urb->RequestPhy != NULL) {\r
    IoMmuUnmap (Ehc->IoMmu, Urb->RequestMap);\r
  }\r
\r
  if (Urb->DataMap != NULL) {\r
    IoMmuUnmap (Ehc->IoMmu, Urb->DataMap);\r
  }\r
\r
  if (Urb->Qh != NULL) {\r
    //\r
    // Ensure that this queue head has been unlinked from the\r
    // schedule data structures. Free all the associated QTDs\r
    //\r
    EhcFreeQtds (Ehc, &Urb->Qh->Qtds);\r
    UsbHcFreeMem (Ehc, Ehc->MemPool, Urb->Qh, sizeof (PEI_EHC_QH));\r
  }\r
}\r
\r
/**\r
  Create a list of QTDs for the URB.\r
\r
  @param  Ehc         The EHCI device.\r
  @param  Urb         The URB to create QTDs for.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Failed to allocate resource for QTD.\r
  @retval EFI_SUCCESS             The QTDs are allocated for the URB.\r
\r
**/\r
EFI_STATUS\r
EhcCreateQtds (\r
  IN PEI_USB2_HC_DEV  *Ehc,\r
  IN PEI_URB          *Urb\r
  )\r
{\r
  USB_ENDPOINT    *Ep;\r
  PEI_EHC_QH      *Qh;\r
  PEI_EHC_QTD     *Qtd;\r
  PEI_EHC_QTD     *StatusQtd;\r
  PEI_EHC_QTD     *NextQtd;\r
  EFI_LIST_ENTRY  *Entry;\r
  UINT32          AlterNext;\r
  UINT8           Toggle;\r
  UINTN           Len;\r
  UINT8           Pid;\r
\r
  ASSERT ((Urb != NULL) && (Urb->Qh != NULL));\r
\r
  //\r
  // EHCI follows the alternet next QTD pointer if it meets\r
  // a short read and the AlterNext pointer is valid. UEFI\r
  // EHCI driver should terminate the transfer except the\r
  // control transfer.\r
  //\r
  Toggle    = 0;\r
  Qh        = Urb->Qh;\r
  Ep        = &Urb->Ep;\r
  StatusQtd = NULL;\r
  AlterNext = QTD_LINK (NULL, TRUE);\r
\r
  if (Ep->Direction == EfiUsbDataIn) {\r
    AlterNext = QTD_LINK (Ehc->ShortReadStop, FALSE);\r
  }\r
\r
  //\r
  // Build the Setup and status packets for control transfer\r
  //\r
  if (Urb->Ep.Type == EHC_CTRL_TRANSFER) {\r
    Len = sizeof (EFI_USB_DEVICE_REQUEST);\r
    Qtd = EhcCreateQtd (Ehc, Urb->RequestPhy, Len, QTD_PID_SETUP, 0, Ep->MaxPacket);\r
\r
    if (Qtd == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    InsertTailList (&Qh->Qtds, &Qtd->QtdList);\r
\r
    //\r
    // Create the status packet now. Set the AlterNext to it. So, when\r
    // EHCI meets a short control read, it can resume at the status stage.\r
    // Use the opposite direction of the data stage, or IN if there is\r
    // no data stage.\r
    //\r
    if (Ep->Direction == EfiUsbDataIn) {\r
      Pid = QTD_PID_OUTPUT;\r
    } else {\r
      Pid = QTD_PID_INPUT;\r
    }\r
\r
    StatusQtd = EhcCreateQtd (Ehc, NULL, 0, Pid, 1, Ep->MaxPacket);\r
\r
    if (StatusQtd == NULL) {\r
      goto ON_ERROR;\r
    }\r
\r
    if (Ep->Direction == EfiUsbDataIn) {\r
      AlterNext = QTD_LINK (StatusQtd, FALSE);\r
    }\r
\r
    Toggle = 1;\r
  }\r
\r
  //\r
  // Build the data packets for all the transfers\r
  //\r
  if (Ep->Direction == EfiUsbDataIn) {\r
    Pid = QTD_PID_INPUT;\r
  } else {\r
    Pid = QTD_PID_OUTPUT;\r
  }\r
\r
  Qtd = NULL;\r
  Len = 0;\r
\r
  while (Len < Urb->DataLen) {\r
    Qtd = EhcCreateQtd (\r
            Ehc,\r
            (UINT8 *)Urb->DataPhy + Len,\r
            Urb->DataLen - Len,\r
            Pid,\r
            Toggle,\r
            Ep->MaxPacket\r
            );\r
\r
    if (Qtd == NULL) {\r
      goto ON_ERROR;\r
    }\r
\r
    Qtd->QtdHw.AltNext = AlterNext;\r
    InsertTailList (&Qh->Qtds, &Qtd->QtdList);\r
\r
    //\r
    // Switch the Toggle bit if odd number of packets are included in the QTD.\r
    //\r
    if (((Qtd->DataLen + Ep->MaxPacket - 1) / Ep->MaxPacket) % 2) {\r
      Toggle = (UINT8)(1 - Toggle);\r
    }\r
\r
    Len += Qtd->DataLen;\r
  }\r
\r
  //\r
  // Insert the status packet for control transfer\r
  //\r
  if (Ep->Type == EHC_CTRL_TRANSFER) {\r
    InsertTailList (&Qh->Qtds, &StatusQtd->QtdList);\r
  }\r
\r
  //\r
  // OK, all the QTDs needed are created. Now, fix the NextQtd point\r
  //\r
  BASE_LIST_FOR_EACH (Entry, &Qh->Qtds) {\r
    Qtd = EFI_LIST_CONTAINER (Entry, PEI_EHC_QTD, QtdList);\r
\r
    //\r
    // break if it is the last entry on the list\r
    //\r
    if (Entry->ForwardLink == &Qh->Qtds) {\r
      break;\r
    }\r
\r
    NextQtd            = EFI_LIST_CONTAINER (Entry->ForwardLink, PEI_EHC_QTD, QtdList);\r
    Qtd->QtdHw.NextQtd = QTD_LINK (NextQtd, FALSE);\r
  }\r
\r
  //\r
  // Link the QTDs to the queue head\r
  //\r
  NextQtd          = EFI_LIST_CONTAINER (Qh->Qtds.ForwardLink, PEI_EHC_QTD, QtdList);\r
  Qh->QhHw.NextQtd = QTD_LINK (NextQtd, FALSE);\r
  return EFI_SUCCESS;\r
\r
ON_ERROR:\r
  EhcFreeQtds (Ehc, &Qh->Qtds);\r
  return EFI_OUT_OF_RESOURCES;\r
}\r
\r
/**\r
  Create a new URB and its associated QTD.\r
\r
  @param  Ehc               The EHCI device.\r
  @param  DevAddr           The device address.\r
  @param  EpAddr            Endpoint addrress & its direction.\r
  @param  DevSpeed          The device speed.\r
  @param  Toggle            Initial data toggle to use.\r
  @param  MaxPacket         The max packet length of the endpoint.\r
  @param  Hub               The transaction translator to use.\r
  @param  Type              The transaction type.\r
  @param  Request           The standard USB request for control transfer.\r
  @param  Data              The user data to transfer.\r
  @param  DataLen           The length of data buffer.\r
  @param  Callback          The function to call when data is transferred.\r
  @param  Context           The context to the callback.\r
  @param  Interval          The interval for interrupt transfer.\r
\r
  @retval the pointer to the created URB or NULL.\r
\r
**/\r
PEI_URB *\r
EhcCreateUrb (\r
  IN PEI_USB2_HC_DEV                     *Ehc,\r
  IN UINT8                               DevAddr,\r
  IN UINT8                               EpAddr,\r
  IN UINT8                               DevSpeed,\r
  IN UINT8                               Toggle,\r
  IN UINTN                               MaxPacket,\r
  IN EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Hub,\r
  IN UINTN                               Type,\r
  IN EFI_USB_DEVICE_REQUEST              *Request,\r
  IN VOID                                *Data,\r
  IN UINTN                               DataLen,\r
  IN EFI_ASYNC_USB_TRANSFER_CALLBACK     Callback,\r
  IN VOID                                *Context,\r
  IN UINTN                               Interval\r
  )\r
{\r
  USB_ENDPOINT           *Ep;\r
  EFI_PHYSICAL_ADDRESS   PhyAddr;\r
  EDKII_IOMMU_OPERATION  MapOp;\r
  EFI_STATUS             Status;\r
  UINTN                  Len;\r
  PEI_URB                *Urb;\r
  VOID                   *Map;\r
\r
  Map = NULL;\r
\r
  Urb            = Ehc->Urb;\r
  Urb->Signature = EHC_URB_SIG;\r
  InitializeListHead (&Urb->UrbList);\r
\r
  Ep            = &Urb->Ep;\r
  Ep->DevAddr   = DevAddr;\r
  Ep->EpAddr    = (UINT8)(EpAddr & 0x0F);\r
  Ep->Direction = (((EpAddr & 0x80) != 0) ? EfiUsbDataIn : EfiUsbDataOut);\r
  Ep->DevSpeed  = DevSpeed;\r
  Ep->MaxPacket = MaxPacket;\r
\r
  Ep->HubAddr = 0;\r
  Ep->HubPort = 0;\r
\r
  if (DevSpeed != EFI_USB_SPEED_HIGH) {\r
    ASSERT (Hub != NULL);\r
\r
    Ep->HubAddr = Hub->TranslatorHubAddress;\r
    Ep->HubPort = Hub->TranslatorPortNumber;\r
  }\r
\r
  Ep->Toggle   = Toggle;\r
  Ep->Type     = Type;\r
  Ep->PollRate = EhcConvertPollRate (Interval);\r
\r
  Urb->Request  = Request;\r
  Urb->Data     = Data;\r
  Urb->DataLen  = DataLen;\r
  Urb->Callback = Callback;\r
  Urb->Context  = Context;\r
  Urb->Qh       = EhcCreateQh (Ehc, &Urb->Ep);\r
\r
  if (Urb->Qh == NULL) {\r
    goto ON_ERROR;\r
  }\r
\r
  Urb->RequestPhy = NULL;\r
  Urb->RequestMap = NULL;\r
  Urb->DataPhy    = NULL;\r
  Urb->DataMap    = NULL;\r
\r
  //\r
  // Map the request and user data\r
  //\r
  if (Request != NULL) {\r
    Len    = sizeof (EFI_USB_DEVICE_REQUEST);\r
    MapOp  = EdkiiIoMmuOperationBusMasterRead;\r
    Status = IoMmuMap (Ehc->IoMmu, MapOp, Request, &Len, &PhyAddr, &Map);\r
\r
    if (EFI_ERROR (Status) || (Len != sizeof (EFI_USB_DEVICE_REQUEST))) {\r
      goto ON_ERROR;\r
    }\r
\r
    Urb->RequestPhy = (VOID *)((UINTN)PhyAddr);\r
    Urb->RequestMap = Map;\r
  }\r
\r
  if (Data != NULL) {\r
    Len = DataLen;\r
\r
    if (Ep->Direction == EfiUsbDataIn) {\r
      MapOp = EdkiiIoMmuOperationBusMasterWrite;\r
    } else {\r
      MapOp = EdkiiIoMmuOperationBusMasterRead;\r
    }\r
\r
    Status = IoMmuMap (Ehc->IoMmu, MapOp, Data, &Len, &PhyAddr, &Map);\r
\r
    if (EFI_ERROR (Status) || (Len != DataLen)) {\r
      goto ON_ERROR;\r
    }\r
\r
    Urb->DataPhy = (VOID *)((UINTN)PhyAddr);\r
    Urb->DataMap = Map;\r
  }\r
\r
  Status = EhcCreateQtds (Ehc, Urb);\r
\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  return Urb;\r
\r
ON_ERROR:\r
  EhcFreeUrb (Ehc, Urb);\r
  return NULL;\r
}\r