[mirror_edk2.git] / MdeModulePkg / Bus / Ufs / UfsBlockIoPei / UfsHci.c

/** @file\r
\r
  Copyright (c) 2014 - 2021, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "UfsBlockIoPei.h"\r
\r
/**\r
  Wait for the value of the specified system memory set to the test value.\r
\r
  @param  Address           The system memory address to test.\r
  @param  MaskValue         The mask value of memory.\r
  @param  TestValue         The test value of memory.\r
  @param  Timeout           The time out value for wait memory set, uses 100ns as a unit.\r
\r
  @retval EFI_TIMEOUT       The system memory setting is time out.\r
  @retval EFI_SUCCESS       The system memory is correct set.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
UfsWaitMemSet (\r
  IN  UINTN   Address,\r
  IN  UINT32  MaskValue,\r
  IN  UINT32  TestValue,\r
  IN  UINT64  Timeout\r
  )\r
{\r
  UINT32   Value;\r
  UINT64   Delay;\r
  BOOLEAN  InfiniteWait;\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32 (Timeout, 10) + 1;\r
\r
  do {\r
    //\r
    // Access PCI MMIO space to see if the value is the tested one.\r
    //\r
    Value = MmioRead32 (Address) & MaskValue;\r
\r
    if (Value == TestValue) {\r
      return EFI_SUCCESS;\r
    }\r
\r
    //\r
    // Stall for 1 microseconds.\r
    //\r
    MicroSecondDelay (1);\r
\r
    Delay--;\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
\r
/**\r
  Dump UIC command execution result for debugging.\r
\r
  @param[in]   UicOpcode  The executed UIC opcode.\r
  @param[in]   Result     The result to be parsed.\r
\r
**/\r
VOID\r
DumpUicCmdExecResult (\r
  IN  UINT8  UicOpcode,\r
  IN  UINT8  Result\r
  )\r
{\r
  if (UicOpcode <= UfsUicDmePeerSet) {\r
    switch (Result) {\r
      case 0x00:\r
        break;\r
      case 0x01:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - INVALID_MIB_ATTRIBUTE\n"));\r
        break;\r
      case 0x02:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - INVALID_MIB_ATTRIBUTE_VALUE\n"));\r
        break;\r
      case 0x03:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - READ_ONLY_MIB_ATTRIBUTE\n"));\r
        break;\r
      case 0x04:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - WRITE_ONLY_MIB_ATTRIBUTE\n"));\r
        break;\r
      case 0x05:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - BAD_INDEX\n"));\r
        break;\r
      case 0x06:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - LOCKED_MIB_ATTRIBUTE\n"));\r
        break;\r
      case 0x07:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - BAD_TEST_FEATURE_INDEX\n"));\r
        break;\r
      case 0x08:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - PEER_COMMUNICATION_FAILURE\n"));\r
        break;\r
      case 0x09:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - BUSY\n"));\r
        break;\r
      case 0x0A:\r
        DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - DME_FAILURE\n"));\r
        break;\r
      default:\r
        ASSERT (FALSE);\r
        break;\r
    }\r
  } else {\r
    switch (Result) {\r
      case 0x00:\r
        break;\r
      case 0x01:\r
        DEBUG ((DEBUG_VERBOSE, "UIC control command fails - FAILURE\n"));\r
        break;\r
      default:\r
        ASSERT (FALSE);\r
        break;\r
    }\r
  }\r
}\r
\r
/**\r
  Dump QUERY RESPONSE UPIU result for debugging.\r
\r
  @param[in]   Result  The result to be parsed.\r
\r
**/\r
VOID\r
DumpQueryResponseResult (\r
  IN  UINT8  Result\r
  )\r
{\r
  switch (Result) {\r
    case 0xF6:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Parameter Not Readable\n"));\r
      break;\r
    case 0xF7:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Parameter Not Writeable\n"));\r
      break;\r
    case 0xF8:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Parameter Already Written\n"));\r
      break;\r
    case 0xF9:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Length\n"));\r
      break;\r
    case 0xFA:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Value\n"));\r
      break;\r
    case 0xFB:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Selector\n"));\r
      break;\r
    case 0xFC:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Index\n"));\r
      break;\r
    case 0xFD:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Idn\n"));\r
      break;\r
    case 0xFE:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Opcode\n"));\r
      break;\r
    case 0xFF:\r
      DEBUG ((DEBUG_VERBOSE, "Query Response with General Failure\n"));\r
      break;\r
    default:\r
      ASSERT (FALSE);\r
      break;\r
  }\r
}\r
\r
/**\r
  Swap little endian to big endian.\r
\r
  @param[in, out] Buffer      The data buffer. In input, it contains little endian data.\r
                              In output, it will become big endian.\r
  @param[in]      BufferSize  The length of converted data.\r
\r
**/\r
VOID\r
SwapLittleEndianToBigEndian (\r
  IN OUT UINT8   *Buffer,\r
  IN     UINT32  BufferSize\r
  )\r
{\r
  UINT32  Index;\r
  UINT8   Temp;\r
  UINT32  SwapCount;\r
\r
  SwapCount = BufferSize / 2;\r
  for (Index = 0; Index < SwapCount; Index++) {\r
    Temp                           = Buffer[Index];\r
    Buffer[Index]                  = Buffer[BufferSize - 1 - Index];\r
    Buffer[BufferSize - 1 - Index] = Temp;\r
  }\r
}\r
\r
/**\r
  Fill TSF field of QUERY REQUEST UPIU.\r
\r
  @param[in, out] TsfBase      The base address of TSF field of QUERY REQUEST UPIU.\r
  @param[in]      Opcode       The opcode of request.\r
  @param[in]      DescId       The descriptor ID of request.\r
  @param[in]      Index        The index of request.\r
  @param[in]      Selector     The selector of request.\r
  @param[in]      Length       The length of transferred data. The maximum is 4.\r
  @param[in]      Value        The value of transferred data.\r
\r
**/\r
VOID\r
UfsFillTsfOfQueryReqUpiu (\r
  IN OUT UTP_UPIU_TSF  *TsfBase,\r
  IN     UINT8         Opcode,\r
  IN     UINT8         DescId    OPTIONAL,\r
  IN     UINT8         Index     OPTIONAL,\r
  IN     UINT8         Selector  OPTIONAL,\r
  IN     UINT16        Length    OPTIONAL,\r
  IN     UINT32        Value     OPTIONAL\r
  )\r
{\r
  ASSERT (TsfBase != NULL);\r
  ASSERT (Opcode <= UtpQueryFuncOpcodeTogFlag);\r
\r
  TsfBase->Opcode = Opcode;\r
  if (Opcode != UtpQueryFuncOpcodeNop) {\r
    TsfBase->DescId   = DescId;\r
    TsfBase->Index    = Index;\r
    TsfBase->Selector = Selector;\r
\r
    if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeWrDesc)) {\r
      SwapLittleEndianToBigEndian ((UINT8 *)&Length, sizeof (Length));\r
      TsfBase->Length = Length;\r
    }\r
\r
    if (Opcode == UtpQueryFuncOpcodeWrAttr) {\r
      SwapLittleEndianToBigEndian ((UINT8 *)&Value, sizeof (Value));\r
      TsfBase->Value = Value;\r
    }\r
  }\r
}\r
\r
/**\r
  Initialize COMMAND UPIU.\r
\r
  @param[in, out] Command         The base address of COMMAND UPIU.\r
  @param[in]      Lun             The Lun on which the SCSI command is executed.\r
  @param[in]      TaskTag         The task tag of request.\r
  @param[in]      Cdb             The cdb buffer containing SCSI command.\r
  @param[in]      CdbLength       The cdb length.\r
  @param[in]      DataDirection   The direction of data transfer.\r
  @param[in]      ExpDataTranLen  The expected transfer data length.\r
\r
  @retval EFI_SUCCESS     The initialization succeed.\r
\r
**/\r
EFI_STATUS\r
UfsInitCommandUpiu (\r
  IN OUT UTP_COMMAND_UPIU    *Command,\r
  IN     UINT8               Lun,\r
  IN     UINT8               TaskTag,\r
  IN     UINT8               *Cdb,\r
  IN     UINT8               CdbLength,\r
  IN     UFS_DATA_DIRECTION  DataDirection,\r
  IN     UINT32              ExpDataTranLen\r
  )\r
{\r
  UINT8  Flags;\r
\r
  ASSERT ((Command != NULL) && (Cdb != NULL));\r
\r
  //\r
  // Task attribute is hard-coded to Ordered.\r
  //\r
  if (DataDirection == UfsDataIn) {\r
    Flags = BIT0 | BIT6;\r
  } else if (DataDirection == UfsDataOut) {\r
    Flags = BIT0 | BIT5;\r
  } else {\r
    Flags = BIT0;\r
  }\r
\r
  //\r
  // Fill UTP COMMAND UPIU associated fields.\r
  //\r
  Command->TransCode = 0x01;\r
  Command->Flags     = Flags;\r
  Command->Lun       = Lun;\r
  Command->TaskTag   = TaskTag;\r
  Command->CmdSet    = 0x00;\r
  SwapLittleEndianToBigEndian ((UINT8 *)&ExpDataTranLen, sizeof (ExpDataTranLen));\r
  Command->ExpDataTranLen = ExpDataTranLen;\r
\r
  CopyMem (Command->Cdb, Cdb, CdbLength);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Initialize UTP PRDT for data transfer.\r
\r
  @param[in] Prdt         The base address of PRDT.\r
  @param[in] Buffer       The buffer to be read or written.\r
  @param[in] BufferSize   The data size to be read or written.\r
\r
  @retval EFI_SUCCESS     The initialization succeed.\r
\r
**/\r
EFI_STATUS\r
UfsInitUtpPrdt (\r
  IN  UTP_TR_PRD  *Prdt,\r
  IN  VOID        *Buffer,\r
  IN  UINT32      BufferSize\r
  )\r
{\r
  UINT32  PrdtIndex;\r
  UINT32  RemainingLen;\r
  UINT8   *Remaining;\r
  UINTN   PrdtNumber;\r
\r
  if ((BufferSize & (BIT0 | BIT1)) != 0) {\r
    BufferSize &= ~(BIT0 | BIT1);\r
    DEBUG ((DEBUG_WARN, "UfsInitUtpPrdt: The BufferSize [%d] is not dword-aligned!\n", BufferSize));\r
  }\r
\r
  if (BufferSize == 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  ASSERT (((UINTN)Buffer & (BIT0 | BIT1)) == 0);\r
\r
  RemainingLen = BufferSize;\r
  Remaining    = Buffer;\r
  PrdtNumber   = (UINTN)DivU64x32 ((UINT64)BufferSize + UFS_MAX_DATA_LEN_PER_PRD - 1, UFS_MAX_DATA_LEN_PER_PRD);\r
\r
  for (PrdtIndex = 0; PrdtIndex < PrdtNumber; PrdtIndex++) {\r
    if (RemainingLen < UFS_MAX_DATA_LEN_PER_PRD) {\r
      Prdt[PrdtIndex].DbCount = (UINT32)RemainingLen - 1;\r
    } else {\r
      Prdt[PrdtIndex].DbCount = UFS_MAX_DATA_LEN_PER_PRD - 1;\r
    }\r
\r
    Prdt[PrdtIndex].DbAddr  = (UINT32)RShiftU64 ((UINT64)(UINTN)Remaining, 2);\r
    Prdt[PrdtIndex].DbAddrU = (UINT32)RShiftU64 ((UINT64)(UINTN)Remaining, 32);\r
    RemainingLen           -= UFS_MAX_DATA_LEN_PER_PRD;\r
    Remaining              += UFS_MAX_DATA_LEN_PER_PRD;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Initialize QUERY REQUEST UPIU.\r
\r
  @param[in, out] QueryReq      The base address of QUERY REQUEST UPIU.\r
  @param[in]      TaskTag       The task tag of request.\r
  @param[in]      Opcode        The opcode of request.\r
  @param[in]      DescId        The descriptor ID of request.\r
  @param[in]      Index         The index of request.\r
  @param[in]      Selector      The selector of request.\r
  @param[in]      DataSize      The data size to be read or written.\r
  @param[in]      Data          The buffer to be read or written.\r
\r
  @retval EFI_SUCCESS           The initialization succeed.\r
\r
**/\r
EFI_STATUS\r
UfsInitQueryRequestUpiu (\r
  IN OUT UTP_QUERY_REQ_UPIU  *QueryReq,\r
  IN     UINT8               TaskTag,\r
  IN     UINT8               Opcode,\r
  IN     UINT8               DescId,\r
  IN     UINT8               Index,\r
  IN     UINT8               Selector,\r
  IN     UINTN               DataSize   OPTIONAL,\r
  IN     UINT8               *Data      OPTIONAL\r
  )\r
{\r
  ASSERT (QueryReq != NULL);\r
\r
  QueryReq->TransCode = 0x16;\r
  QueryReq->TaskTag   = TaskTag;\r
  if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeRdFlag) || (Opcode == UtpQueryFuncOpcodeRdAttr)) {\r
    QueryReq->QueryFunc = QUERY_FUNC_STD_READ_REQ;\r
  } else {\r
    QueryReq->QueryFunc = QUERY_FUNC_STD_WRITE_REQ;\r
  }\r
\r
  if (Opcode == UtpQueryFuncOpcodeWrAttr) {\r
    UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, 0, *(UINT32 *)Data);\r
  } else if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeWrDesc)) {\r
    UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, (UINT16)DataSize, 0);\r
  } else {\r
    UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, 0, 0);\r
  }\r
\r
  if (Opcode == UtpQueryFuncOpcodeWrDesc) {\r
    CopyMem (QueryReq + 1, Data, DataSize);\r
\r
    SwapLittleEndianToBigEndian ((UINT8 *)&DataSize, sizeof (UINT16));\r
    QueryReq->DataSegLen = (UINT16)DataSize;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Allocate COMMAND/RESPONSE UPIU for filling UTP TRD's command descriptor field.\r
\r
  @param[in]  Private           The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]  Lun               The Lun on which the SCSI command is executed.\r
  @param[in]  Packet            The pointer to the UFS_SCSI_REQUEST_PACKET data structure.\r
  @param[in]  Trd               The pointer to the UTP Transfer Request Descriptor.\r
  @param[out] BufferMap         A resulting value, if not NULL, to pass to IoMmuUnmap().\r
\r
  @retval EFI_SUCCESS           The creation succeed.\r
  @retval EFI_DEVICE_ERROR      The creation failed.\r
  @retval EFI_OUT_OF_RESOURCES  The memory resource is insufficient.\r
\r
**/\r
EFI_STATUS\r
UfsCreateScsiCommandDesc (\r
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN     UINT8                     Lun,\r
  IN     UFS_SCSI_REQUEST_PACKET   *Packet,\r
  IN     UTP_TRD                   *Trd,\r
  OUT VOID                         **BufferMap\r
  )\r
{\r
  UINT8                  *CommandDesc;\r
  UINTN                  TotalLen;\r
  UINTN                  PrdtNumber;\r
  VOID                   *Buffer;\r
  UINT32                 Length;\r
  UTP_COMMAND_UPIU       *CommandUpiu;\r
  UTP_TR_PRD             *PrdtBase;\r
  UFS_DATA_DIRECTION     DataDirection;\r
  EFI_STATUS             Status;\r
  EDKII_IOMMU_OPERATION  MapOp;\r
  UINTN                  MapLength;\r
  EFI_PHYSICAL_ADDRESS   BufferPhyAddr;\r
\r
  ASSERT ((Private != NULL) && (Packet != NULL) && (Trd != NULL));\r
\r
  BufferPhyAddr = 0;\r
\r
  if (Packet->DataDirection == UfsDataIn) {\r
    Buffer        = Packet->InDataBuffer;\r
    Length        = Packet->InTransferLength;\r
    DataDirection = UfsDataIn;\r
    MapOp         = EdkiiIoMmuOperationBusMasterWrite;\r
  } else {\r
    Buffer        = Packet->OutDataBuffer;\r
    Length        = Packet->OutTransferLength;\r
    DataDirection = UfsDataOut;\r
    MapOp         = EdkiiIoMmuOperationBusMasterRead;\r
  }\r
\r
  if (Length == 0) {\r
    DataDirection = UfsNoData;\r
  } else {\r
    MapLength = Length;\r
    Status    = IoMmuMap (MapOp, Buffer, &MapLength, &BufferPhyAddr, BufferMap);\r
\r
    if (EFI_ERROR (Status) || (MapLength != Length)) {\r
      DEBUG ((DEBUG_ERROR, "UfsCreateScsiCommandDesc: Fail to map data buffer.\n"));\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
  }\r
\r
  PrdtNumber = (UINTN)DivU64x32 ((UINT64)Length + UFS_MAX_DATA_LEN_PER_PRD - 1, UFS_MAX_DATA_LEN_PER_PRD);\r
\r
  TotalLen    = ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU)) + PrdtNumber * sizeof (UTP_TR_PRD);\r
  CommandDesc = UfsPeimAllocateMem (Private->Pool, TotalLen);\r
  if (CommandDesc == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  CommandUpiu = (UTP_COMMAND_UPIU *)CommandDesc;\r
  PrdtBase    = (UTP_TR_PRD *)(CommandDesc + ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU)));\r
\r
  UfsInitCommandUpiu (CommandUpiu, Lun, Private->TaskTag++, Packet->Cdb, Packet->CdbLength, DataDirection, Length);\r
  UfsInitUtpPrdt (PrdtBase, (VOID *)(UINTN)BufferPhyAddr, Length);\r
\r
  //\r
  // Fill UTP_TRD associated fields\r
  // NOTE: Some UFS host controllers request the Response UPIU and the Physical Region Description Table\r
  // *MUST* be located at a 64-bit aligned boundary.\r
  //\r
  Trd->Int    = UFS_INTERRUPT_COMMAND;\r
  Trd->Dd     = DataDirection;\r
  Trd->Ct     = UFS_STORAGE_COMMAND_TYPE;\r
  Trd->Ocs    = UFS_HC_TRD_OCS_INIT_VALUE;\r
  Trd->UcdBa  = (UINT32)RShiftU64 ((UINT64)(UINTN)CommandUpiu, 7);\r
  Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)(UINTN)CommandUpiu, 32);\r
  Trd->RuL    = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU)), sizeof (UINT32));\r
  Trd->RuO    = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)), sizeof (UINT32));\r
  Trd->PrdtL  = (UINT16)PrdtNumber;\r
  Trd->PrdtO  = (UINT16)DivU64x32 ((UINT64)(ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU))), sizeof (UINT32));\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Allocate QUERY REQUEST/QUERY RESPONSE UPIU for filling UTP TRD's command descriptor field.\r
\r
  @param[in]  Private           The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]  Packet            The pointer to the UFS_DEVICE_MANAGEMENT_REQUEST_PACKET data structure.\r
  @param[in]  Trd               The pointer to the UTP Transfer Request Descriptor.\r
\r
  @retval EFI_SUCCESS           The creation succeed.\r
  @retval EFI_DEVICE_ERROR      The creation failed.\r
  @retval EFI_OUT_OF_RESOURCES  The memory resource is insufficient.\r
  @retval EFI_INVALID_PARAMETER The parameter passed in is invalid.\r
\r
**/\r
EFI_STATUS\r
UfsCreateDMCommandDesc (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA              *Private,\r
  IN  UFS_DEVICE_MANAGEMENT_REQUEST_PACKET  *Packet,\r
  IN  UTP_TRD                               *Trd\r
  )\r
{\r
  UINT8               *CommandDesc;\r
  UINTN               TotalLen;\r
  UTP_QUERY_REQ_UPIU  *QueryReqUpiu;\r
  UINT8               Opcode;\r
  UINT32              DataSize;\r
  UINT8               *Data;\r
  UINT8               DataDirection;\r
\r
  ASSERT ((Private != NULL) && (Packet != NULL) && (Trd != NULL));\r
\r
  Opcode = Packet->Opcode;\r
  if ((Opcode > UtpQueryFuncOpcodeTogFlag) || (Opcode == UtpQueryFuncOpcodeNop)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  DataDirection = Packet->DataDirection;\r
  if (DataDirection == UfsDataIn) {\r
    DataSize = Packet->InTransferLength;\r
    Data     = Packet->InDataBuffer;\r
  } else if (DataDirection == UfsDataOut) {\r
    DataSize = Packet->OutTransferLength;\r
    Data     = Packet->OutDataBuffer;\r
  } else {\r
    DataSize = 0;\r
    Data     = NULL;\r
  }\r
\r
  if (((Opcode != UtpQueryFuncOpcodeRdFlag) && (Opcode != UtpQueryFuncOpcodeSetFlag) &&\r
       (Opcode != UtpQueryFuncOpcodeClrFlag) && (Opcode != UtpQueryFuncOpcodeTogFlag)) &&\r
      ((DataSize == 0) || (Data == NULL)))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((Opcode == UtpQueryFuncOpcodeWrAttr) && (DataSize != sizeof (UINT32))) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((Opcode == UtpQueryFuncOpcodeWrDesc) || (Opcode == UtpQueryFuncOpcodeRdDesc)) {\r
    TotalLen = ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)) + ROUNDUP8 (DataSize);\r
  } else {\r
    TotalLen = ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU));\r
  }\r
\r
  CommandDesc = UfsPeimAllocateMem (Private->Pool, TotalLen);\r
  if (CommandDesc == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Initialize UTP QUERY REQUEST UPIU\r
  //\r
  QueryReqUpiu = (UTP_QUERY_REQ_UPIU *)CommandDesc;\r
  UfsInitQueryRequestUpiu (\r
    QueryReqUpiu,\r
    Private->TaskTag++,\r
    Opcode,\r
    Packet->DescId,\r
    Packet->Index,\r
    Packet->Selector,\r
    DataSize,\r
    Data\r
    );\r
\r
  //\r
  // Fill UTP_TRD associated fields\r
  // NOTE: Some UFS host controllers request the Query Response UPIU *MUST* be located at a 64-bit aligned boundary.\r
  //\r
  Trd->Int    = UFS_INTERRUPT_COMMAND;\r
  Trd->Dd     = DataDirection;\r
  Trd->Ct     = UFS_STORAGE_COMMAND_TYPE;\r
  Trd->Ocs    = UFS_HC_TRD_OCS_INIT_VALUE;\r
  Trd->UcdBa  = (UINT32)RShiftU64 ((UINT64)(UINTN)QueryReqUpiu, 7);\r
  Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)(UINTN)QueryReqUpiu, 32);\r
  if (Opcode == UtpQueryFuncOpcodeWrDesc) {\r
    Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)), sizeof (UINT32));\r
    Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (DataSize), sizeof (UINT32));\r
  } else {\r
    Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)) + ROUNDUP8 (DataSize), sizeof (UINT32));\r
    Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)), sizeof (UINT32));\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Allocate NOP IN and NOP OUT UPIU for filling UTP TRD's command descriptor field.\r
\r
  @param[in]  Private           The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]  Trd               The pointer to the UTP Transfer Request Descriptor.\r
\r
  @retval EFI_SUCCESS           The creation succeed.\r
  @retval EFI_DEVICE_ERROR      The creation failed.\r
  @retval EFI_OUT_OF_RESOURCES  The memory resource is insufficient.\r
\r
**/\r
EFI_STATUS\r
UfsCreateNopCommandDesc (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN  UTP_TRD                   *Trd\r
  )\r
{\r
  UINT8             *CommandDesc;\r
  UINTN             TotalLen;\r
  UTP_NOP_OUT_UPIU  *NopOutUpiu;\r
\r
  ASSERT ((Private != NULL) && (Trd != NULL));\r
\r
  TotalLen    = ROUNDUP8 (sizeof (UTP_NOP_OUT_UPIU)) + ROUNDUP8 (sizeof (UTP_NOP_IN_UPIU));\r
  CommandDesc = UfsPeimAllocateMem (Private->Pool, TotalLen);\r
  if (CommandDesc == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  NopOutUpiu = (UTP_NOP_OUT_UPIU *)CommandDesc;\r
\r
  NopOutUpiu->TaskTag = Private->TaskTag++;\r
\r
  //\r
  // Fill UTP_TRD associated fields\r
  // NOTE: Some UFS host controllers request the Nop Out UPIU *MUST* be located at a 64-bit aligned boundary.\r
  //\r
  Trd->Int    = UFS_INTERRUPT_COMMAND;\r
  Trd->Dd     = 0x00;\r
  Trd->Ct     = UFS_STORAGE_COMMAND_TYPE;\r
  Trd->Ocs    = UFS_HC_TRD_OCS_INIT_VALUE;\r
  Trd->UcdBa  = (UINT32)RShiftU64 ((UINT64)(UINTN)NopOutUpiu, 7);\r
  Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)(UINTN)NopOutUpiu, 32);\r
  Trd->RuL    = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_NOP_IN_UPIU)), sizeof (UINT32));\r
  Trd->RuO    = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_NOP_OUT_UPIU)), sizeof (UINT32));\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Find out available slot in transfer list of a UFS device.\r
\r
  @param[in]  Private       The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[out] Slot          The available slot.\r
\r
  @retval EFI_SUCCESS       The available slot was found successfully.\r
\r
**/\r
EFI_STATUS\r
UfsFindAvailableSlotInTrl (\r
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  OUT UINT8                        *Slot\r
  )\r
{\r
  ASSERT ((Private != NULL) && (Slot != NULL));\r
\r
  //\r
  // The simplest algo to always use slot 0.\r
  // TODO: enhance it to support async transfer with multiple slot.\r
  //\r
  *Slot = 0;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Start specified slot in transfer list of a UFS device.\r
\r
  @param[in]  Private       The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]  Slot          The slot to be started.\r
\r
**/\r
VOID\r
UfsStartExecCmd (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN  UINT8                     Slot\r
  )\r
{\r
  UINTN   UfsHcBase;\r
  UINTN   Address;\r
  UINT32  Data;\r
\r
  UfsHcBase = Private->UfsHcBase;\r
\r
  Address = UfsHcBase + UFS_HC_UTRLRSR_OFFSET;\r
  Data    = MmioRead32 (Address);\r
  if ((Data & UFS_HC_UTRLRSR) != UFS_HC_UTRLRSR) {\r
    MmioWrite32 (Address, UFS_HC_UTRLRSR);\r
  }\r
\r
  Address = UfsHcBase + UFS_HC_UTRLDBR_OFFSET;\r
  MmioWrite32 (Address, BIT0 << Slot);\r
}\r
\r
/**\r
  Stop specified slot in transfer list of a UFS device.\r
\r
  @param[in]  Private       The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]  Slot          The slot to be stop.\r
\r
**/\r
VOID\r
UfsStopExecCmd (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN  UINT8                     Slot\r
  )\r
{\r
  UINTN   UfsHcBase;\r
  UINTN   Address;\r
  UINT32  Data;\r
\r
  UfsHcBase = Private->UfsHcBase;\r
\r
  Address = UfsHcBase + UFS_HC_UTRLDBR_OFFSET;\r
  Data    = MmioRead32 (Address);\r
  if ((Data & (BIT0 << Slot)) != 0) {\r
    Address = UfsHcBase + UFS_HC_UTRLCLR_OFFSET;\r
    Data    = MmioRead32 (Address);\r
    MmioWrite32 (Address, (Data & ~(BIT0 << Slot)));\r
  }\r
}\r
\r
/**\r
  Extracts return data from query response upiu.\r
\r
  @param[in, out] Packet        Pointer to the UFS_DEVICE_MANAGEMENT_REQUEST_PACKET.\r
  @param[in]      QueryResp     Pointer to the query response.\r
\r
  @retval EFI_INVALID_PARAMETER Packet or QueryResp are empty or opcode is invalid.\r
  @retval EFI_DEVICE_ERROR      Data returned from device is invalid.\r
  @retval EFI_SUCCESS           Data extracted.\r
\r
**/\r
EFI_STATUS\r
UfsGetReturnDataFromQueryResponse (\r
  IN OUT UFS_DEVICE_MANAGEMENT_REQUEST_PACKET  *Packet,\r
  IN     UTP_QUERY_RESP_UPIU                   *QueryResp\r
  )\r
{\r
  UINT16  ReturnDataSize;\r
\r
  ReturnDataSize = 0;\r
\r
  if ((Packet == NULL) || (QueryResp == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  switch (Packet->Opcode) {\r
    case UtpQueryFuncOpcodeRdDesc:\r
      ReturnDataSize = QueryResp->Tsf.Length;\r
      SwapLittleEndianToBigEndian ((UINT8 *)&ReturnDataSize, sizeof (UINT16));\r
      //\r
      // Make sure the hardware device does not return more data than expected.\r
      //\r
      if (ReturnDataSize > Packet->InTransferLength) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      CopyMem (Packet->InDataBuffer, (QueryResp + 1), ReturnDataSize);\r
      Packet->InTransferLength = ReturnDataSize;\r
      break;\r
    case UtpQueryFuncOpcodeWrDesc:\r
      ReturnDataSize = QueryResp->Tsf.Length;\r
      SwapLittleEndianToBigEndian ((UINT8 *)&ReturnDataSize, sizeof (UINT16));\r
      Packet->OutTransferLength = ReturnDataSize;\r
      break;\r
    case UtpQueryFuncOpcodeRdFlag:\r
      //\r
      // The 'FLAG VALUE' field is at byte offset 3 of QueryResp->Tsf.Value\r
      //\r
      *((UINT8 *)(Packet->InDataBuffer)) = *((UINT8 *)&(QueryResp->Tsf.Value) + 3);\r
      break;\r
    case UtpQueryFuncOpcodeSetFlag:\r
    case UtpQueryFuncOpcodeClrFlag:\r
    case UtpQueryFuncOpcodeTogFlag:\r
      //\r
      // The 'FLAG VALUE' field is at byte offset 3 of QueryResp->Tsf.Value\r
      //\r
      *((UINT8 *)(Packet->OutDataBuffer)) = *((UINT8 *)&(QueryResp->Tsf.Value) + 3);\r
      break;\r
    default:\r
      return EFI_INVALID_PARAMETER;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Creates Transfer Request descriptor and sends Query Request to the device.\r
\r
  @param[in]      Private       Pointer to the UFS_PEIM_HC_PRIVATE_DATA.\r
  @param[in, out] Packet        Pointer to the UFS_DEVICE_MANAGEMENT_REQUEST_PACKET.\r
\r
  @retval EFI_SUCCESS           The device descriptor was read/written successfully.\r
  @retval EFI_INVALID_PARAMETER The DescId, Index and Selector fields in Packet are invalid\r
                                combination to point to a type of UFS device descriptor.\r
  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to r/w the device descriptor.\r
  @retval EFI_TIMEOUT           A timeout occurred while waiting for the completion of r/w the device descriptor.\r
\r
**/\r
EFI_STATUS\r
UfsSendDmRequestRetry (\r
  IN     UFS_PEIM_HC_PRIVATE_DATA              *Private,\r
  IN OUT UFS_DEVICE_MANAGEMENT_REQUEST_PACKET  *Packet\r
  )\r
{\r
  UINT8                Slot;\r
  EFI_STATUS           Status;\r
  UTP_TRD              *Trd;\r
  UINTN                Address;\r
  UTP_QUERY_RESP_UPIU  *QueryResp;\r
  UINT8                *CmdDescBase;\r
  UINT32               CmdDescSize;\r
\r
  //\r
  // Find out which slot of transfer request list is available.\r
  //\r
  Status = UfsFindAvailableSlotInTrl (Private, &Slot);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Trd = ((UTP_TRD *)Private->UtpTrlBase) + Slot;\r
  //\r
  // Fill transfer request descriptor to this slot.\r
  //\r
  Status = UfsCreateDMCommandDesc (Private, Packet, Trd);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Failed to create DM command descriptor\n"));\r
    return Status;\r
  }\r
\r
  //\r
  // Check the transfer request result.\r
  //\r
  CmdDescBase = (UINT8 *)(UINTN)(LShiftU64 ((UINT64)Trd->UcdBaU, 32) | LShiftU64 ((UINT64)Trd->UcdBa, 7));\r
  QueryResp   = (UTP_QUERY_RESP_UPIU *)(CmdDescBase + Trd->RuO * sizeof (UINT32));\r
  CmdDescSize = Trd->RuO * sizeof (UINT32) + Trd->RuL * sizeof (UINT32);\r
\r
  //\r
  // Start to execute the transfer request.\r
  //\r
  UfsStartExecCmd (Private, Slot);\r
\r
  //\r
  // Wait for the completion of the transfer request.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTRLDBR_OFFSET;\r
  Status  = UfsWaitMemSet (Address, (BIT0 << Slot), 0, Packet->Timeout);\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  if ((Trd->Ocs != 0) || (QueryResp->QueryResp != UfsUtpQueryResponseSuccess)) {\r
    DEBUG ((DEBUG_ERROR, "Failed to send query request, OCS = %X, QueryResp = %X\n", Trd->Ocs, QueryResp->QueryResp));\r
    DumpQueryResponseResult (QueryResp->QueryResp);\r
    Status = EFI_DEVICE_ERROR;\r
    goto Exit;\r
  }\r
\r
  Status = UfsGetReturnDataFromQueryResponse (Packet, QueryResp);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Failed to get return data from query response\n"));\r
    goto Exit;\r
  }\r
\r
Exit:\r
  UfsStopExecCmd (Private, Slot);\r
  UfsPeimFreeMem (Private->Pool, CmdDescBase, CmdDescSize);\r
\r
  return Status;\r
}\r
\r
/**\r
  Sends Query Request to the device. Query is sent until device responds correctly or counter runs out.\r
\r
  @param[in]      Private       Pointer to the UFS_PEIM_HC_PRIVATE_DATA.\r
  @param[in, out] Packet        Pointer to the UFS_DEVICE_MANAGEMENT_REQUEST_PACKET.\r
\r
  @retval EFI_SUCCESS           The device responded correctly to the Query request.\r
  @retval EFI_INVALID_PARAMETER The DescId, Index and Selector fields in Packet are invalid\r
                                combination to point to a type of UFS device descriptor.\r
  @retval EFI_DEVICE_ERROR      A device error occurred while waiting for the response from the device.\r
  @retval EFI_TIMEOUT           A timeout occurred while waiting for the completion of the operation.\r
\r
**/\r
EFI_STATUS\r
UfsSendDmRequest (\r
  IN     UFS_PEIM_HC_PRIVATE_DATA              *Private,\r
  IN OUT UFS_DEVICE_MANAGEMENT_REQUEST_PACKET  *Packet\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT8       Retry;\r
\r
  Status = EFI_SUCCESS;\r
\r
  for (Retry = 0; Retry < 5; Retry++) {\r
    Status = UfsSendDmRequestRetry (Private, Packet);\r
    if (!EFI_ERROR (Status)) {\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  DEBUG ((DEBUG_ERROR, "Failed to get response from the device after %d retries\n", Retry));\r
  return Status;\r
}\r
\r
/**\r
  Read or write specified device descriptor of a UFS device.\r
\r
  @param[in]      Private       The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]      Read          The boolean variable to show r/w direction.\r
  @param[in]      DescId        The ID of device descriptor.\r
  @param[in]      Index         The Index of device descriptor.\r
  @param[in]      Selector      The Selector of device descriptor.\r
  @param[in, out] Descriptor    The buffer of device descriptor to be read or written.\r
  @param[in]      DescSize      The size of device descriptor buffer.\r
\r
  @retval EFI_SUCCESS           The device descriptor was read/written successfully.\r
  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to r/w the device descriptor.\r
  @retval EFI_TIMEOUT           A timeout occurred while waiting for the completion of r/w the device descriptor.\r
\r
**/\r
EFI_STATUS\r
UfsRwDeviceDesc (\r
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN     BOOLEAN                   Read,\r
  IN     UINT8                     DescId,\r
  IN     UINT8                     Index,\r
  IN     UINT8                     Selector,\r
  IN OUT VOID                      *Descriptor,\r
  IN     UINT32                    DescSize\r
  )\r
{\r
  EFI_STATUS                            Status;\r
  UFS_DEVICE_MANAGEMENT_REQUEST_PACKET  Packet;\r
\r
  ZeroMem (&Packet, sizeof (UFS_DEVICE_MANAGEMENT_REQUEST_PACKET));\r
\r
  if (Read) {\r
    Packet.DataDirection    = UfsDataIn;\r
    Packet.InDataBuffer     = Descriptor;\r
    Packet.InTransferLength = DescSize;\r
    Packet.Opcode           = UtpQueryFuncOpcodeRdDesc;\r
  } else {\r
    Packet.DataDirection     = UfsDataOut;\r
    Packet.OutDataBuffer     = Descriptor;\r
    Packet.OutTransferLength = DescSize;\r
    Packet.Opcode            = UtpQueryFuncOpcodeWrDesc;\r
  }\r
\r
  Packet.DescId   = DescId;\r
  Packet.Index    = Index;\r
  Packet.Selector = Selector;\r
  Packet.Timeout  = UFS_TIMEOUT;\r
\r
  Status = UfsSendDmRequest (Private, &Packet);\r
  return Status;\r
}\r
\r
/**\r
  Read or write specified flag of a UFS device.\r
\r
  @param[in]      Private       The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]      Read          The boolean variable to show r/w direction.\r
  @param[in]      FlagId        The ID of flag to be read or written.\r
  @param[in, out] Value         The value to set or clear flag.\r
\r
  @retval EFI_SUCCESS           The flag was read/written successfully.\r
  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to r/w the flag.\r
  @retval EFI_TIMEOUT           A timeout occurred while waiting for the completion of r/w the flag.\r
\r
**/\r
EFI_STATUS\r
UfsRwFlags (\r
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN     BOOLEAN                   Read,\r
  IN     UINT8                     FlagId,\r
  IN OUT UINT8                     *Value\r
  )\r
{\r
  EFI_STATUS                            Status;\r
  UFS_DEVICE_MANAGEMENT_REQUEST_PACKET  Packet;\r
\r
  if (Value == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  ZeroMem (&Packet, sizeof (UFS_DEVICE_MANAGEMENT_REQUEST_PACKET));\r
\r
  if (Read) {\r
    ASSERT (Value != NULL);\r
    Packet.DataDirection    = UfsDataIn;\r
    Packet.InDataBuffer     = (VOID *)Value;\r
    Packet.InTransferLength = 0;\r
    Packet.Opcode           = UtpQueryFuncOpcodeRdFlag;\r
  } else {\r
    Packet.DataDirection     = UfsDataOut;\r
    Packet.OutDataBuffer     = (VOID *)Value;\r
    Packet.OutTransferLength = 0;\r
    if (*Value == 1) {\r
      Packet.Opcode = UtpQueryFuncOpcodeSetFlag;\r
    } else if (*Value == 0) {\r
      Packet.Opcode = UtpQueryFuncOpcodeClrFlag;\r
    } else {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  Packet.DescId   = FlagId;\r
  Packet.Index    = 0;\r
  Packet.Selector = 0;\r
  Packet.Timeout  = UFS_TIMEOUT;\r
\r
  Status = UfsSendDmRequest (Private, &Packet);\r
\r
  return Status;\r
}\r
\r
/**\r
  Set specified flag to 1 on a UFS device.\r
\r
  @param[in]  Private           The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]  FlagId            The ID of flag to be set.\r
\r
  @retval EFI_SUCCESS           The flag was set successfully.\r
  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to set the flag.\r
  @retval EFI_TIMEOUT           A timeout occurred while waiting for the completion of setting the flag.\r
\r
**/\r
EFI_STATUS\r
UfsSetFlag (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN  UINT8                     FlagId\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT8       Value;\r
\r
  Value  = 1;\r
  Status = UfsRwFlags (Private, FALSE, FlagId, &Value);\r
\r
  return Status;\r
}\r
\r
/**\r
  Sends NOP IN cmd to a UFS device for initialization process request.\r
  For more details, please refer to UFS 2.0 spec Figure 13.3.\r
\r
  @param[in]  Private           The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
\r
  @retval EFI_SUCCESS           The NOP IN command was sent by the host. The NOP OUT response was\r
                                received successfully.\r
  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to execute NOP IN command.\r
  @retval EFI_OUT_OF_RESOURCES  The resource for transfer is not available.\r
  @retval EFI_TIMEOUT           A timeout occurred while waiting for the NOP IN command to execute.\r
\r
**/\r
EFI_STATUS\r
UfsExecNopCmds (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private\r
  )\r
{\r
  EFI_STATUS       Status;\r
  UINT8            Slot;\r
  UTP_TRD          *Trd;\r
  UTP_NOP_IN_UPIU  *NopInUpiu;\r
  UINT8            *CmdDescBase;\r
  UINT32           CmdDescSize;\r
  UINTN            Address;\r
\r
  //\r
  // Find out which slot of transfer request list is available.\r
  //\r
  Status = UfsFindAvailableSlotInTrl (Private, &Slot);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Trd    = ((UTP_TRD *)Private->UtpTrlBase) + Slot;\r
  Status = UfsCreateNopCommandDesc (Private, Trd);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Check the transfer request result.\r
  //\r
  CmdDescBase = (UINT8 *)(UINTN)(LShiftU64 ((UINT64)Trd->UcdBaU, 32) | LShiftU64 ((UINT64)Trd->UcdBa, 7));\r
  NopInUpiu   = (UTP_NOP_IN_UPIU *)(CmdDescBase + Trd->RuO * sizeof (UINT32));\r
  CmdDescSize = Trd->RuO * sizeof (UINT32) + Trd->RuL * sizeof (UINT32);\r
\r
  //\r
  // Start to execute the transfer request.\r
  //\r
  UfsStartExecCmd (Private, Slot);\r
\r
  //\r
  // Wait for the completion of the transfer request.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTRLDBR_OFFSET;\r
  Status  = UfsWaitMemSet (Address, BIT0 << Slot, 0, UFS_TIMEOUT);\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  if (NopInUpiu->Resp != 0) {\r
    Status = EFI_DEVICE_ERROR;\r
  } else {\r
    Status = EFI_SUCCESS;\r
  }\r
\r
Exit:\r
  UfsStopExecCmd (Private, Slot);\r
  UfsPeimFreeMem (Private->Pool, CmdDescBase, CmdDescSize);\r
\r
  return Status;\r
}\r
\r
/**\r
  Sends a UFS-supported SCSI Request Packet to a UFS device that is attached to the UFS host controller.\r
\r
  @param[in]      Private       The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in]      Lun           The LUN of the UFS device to send the SCSI Request Packet.\r
  @param[in, out] Packet        A pointer to the SCSI Request Packet to send to a specified Lun of the\r
                                UFS device.\r
\r
  @retval EFI_SUCCESS           The SCSI Request Packet was sent by the host. For bi-directional\r
                                commands, InTransferLength bytes were transferred from\r
                                InDataBuffer. For write and bi-directional commands,\r
                                OutTransferLength bytes were transferred by\r
                                OutDataBuffer.\r
  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to send the SCSI Request\r
                                Packet.\r
  @retval EFI_OUT_OF_RESOURCES  The resource for transfer is not available.\r
  @retval EFI_TIMEOUT           A timeout occurred while waiting for the SCSI Request Packet to execute.\r
\r
**/\r
EFI_STATUS\r
UfsExecScsiCmds (\r
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN     UINT8                     Lun,\r
  IN OUT UFS_SCSI_REQUEST_PACKET   *Packet\r
  )\r
{\r
  EFI_STATUS         Status;\r
  UINT8              Slot;\r
  UTP_TRD            *Trd;\r
  UINTN              Address;\r
  UINT8              *CmdDescBase;\r
  UINT32             CmdDescSize;\r
  UTP_RESPONSE_UPIU  *Response;\r
  UINT16             SenseDataLen;\r
  UINT32             ResTranCount;\r
  VOID               *PacketBufferMap;\r
\r
  //\r
  // Find out which slot of transfer request list is available.\r
  //\r
  Status = UfsFindAvailableSlotInTrl (Private, &Slot);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Trd             = ((UTP_TRD *)Private->UtpTrlBase) + Slot;\r
  PacketBufferMap = NULL;\r
\r
  //\r
  // Fill transfer request descriptor to this slot.\r
  //\r
  Status = UfsCreateScsiCommandDesc (Private, Lun, Packet, Trd, &PacketBufferMap);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  CmdDescBase = (UINT8 *)(UINTN)(LShiftU64 ((UINT64)Trd->UcdBaU, 32) | LShiftU64 ((UINT64)Trd->UcdBa, 7));\r
  CmdDescSize = Trd->PrdtO * sizeof (UINT32) + Trd->PrdtL * sizeof (UTP_TR_PRD);\r
\r
  //\r
  // Start to execute the transfer request.\r
  //\r
  UfsStartExecCmd (Private, Slot);\r
\r
  //\r
  // Wait for the completion of the transfer request.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTRLDBR_OFFSET;\r
  Status  = UfsWaitMemSet (Address, BIT0 << Slot, 0, Packet->Timeout);\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  //\r
  // Get sense data if exists\r
  //\r
  Response     = (UTP_RESPONSE_UPIU *)(CmdDescBase + Trd->RuO * sizeof (UINT32));\r
  SenseDataLen = Response->SenseDataLen;\r
  SwapLittleEndianToBigEndian ((UINT8 *)&SenseDataLen, sizeof (UINT16));\r
\r
  if ((Packet->SenseDataLength != 0) && (Packet->SenseData != NULL)) {\r
    //\r
    // Make sure the hardware device does not return more data than expected.\r
    //\r
    if (SenseDataLen <= Packet->SenseDataLength) {\r
      CopyMem (Packet->SenseData, Response->SenseData, SenseDataLen);\r
      Packet->SenseDataLength = (UINT8)SenseDataLen;\r
    } else {\r
      Packet->SenseDataLength = 0;\r
    }\r
  }\r
\r
  //\r
  // Check the transfer request result.\r
  //\r
  if (Response->Response != 0) {\r
    DEBUG ((DEBUG_ERROR, "UfsExecScsiCmds() fails with Target Failure\n"));\r
    Status = EFI_DEVICE_ERROR;\r
    goto Exit;\r
  }\r
\r
  if (Trd->Ocs == 0) {\r
    if (Packet->DataDirection == UfsDataIn) {\r
      if ((Response->Flags & BIT5) == BIT5) {\r
        ResTranCount = Response->ResTranCount;\r
        SwapLittleEndianToBigEndian ((UINT8 *)&ResTranCount, sizeof (UINT32));\r
        Packet->InTransferLength -= ResTranCount;\r
      }\r
    } else if (Packet->DataDirection == UfsDataOut) {\r
      if ((Response->Flags & BIT5) == BIT5) {\r
        ResTranCount = Response->ResTranCount;\r
        SwapLittleEndianToBigEndian ((UINT8 *)&ResTranCount, sizeof (UINT32));\r
        Packet->OutTransferLength -= ResTranCount;\r
      }\r
    }\r
  } else {\r
    Status = EFI_DEVICE_ERROR;\r
  }\r
\r
Exit:\r
  if (PacketBufferMap != NULL) {\r
    IoMmuUnmap (PacketBufferMap);\r
  }\r
\r
  UfsStopExecCmd (Private, Slot);\r
  UfsPeimFreeMem (Private->Pool, CmdDescBase, CmdDescSize);\r
\r
  return Status;\r
}\r
\r
/**\r
  Sent UIC DME_LINKSTARTUP command to start the link startup procedure.\r
\r
  @param[in] Private          The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
  @param[in] UicOpcode        The opcode of the UIC command.\r
  @param[in] Arg1             The value for 1st argument of the UIC command.\r
  @param[in] Arg2             The value for 2nd argument of the UIC command.\r
  @param[in] Arg3             The value for 3rd argument of the UIC command.\r
\r
  @return EFI_SUCCESS      Successfully execute this UIC command and detect attached UFS device.\r
  @return EFI_DEVICE_ERROR Fail to execute this UIC command and detect attached UFS device.\r
  @return EFI_NOT_FOUND    The presence of the UFS device isn't detected.\r
\r
**/\r
EFI_STATUS\r
UfsExecUicCommands (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private,\r
  IN  UINT8                     UicOpcode,\r
  IN  UINT32                    Arg1,\r
  IN  UINT32                    Arg2,\r
  IN  UINT32                    Arg3\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Address;\r
  UINT32      Data;\r
  UINTN       UfsHcBase;\r
\r
  UfsHcBase = Private->UfsHcBase;\r
  Address   = UfsHcBase + UFS_HC_IS_OFFSET;\r
  Data      = MmioRead32 (Address);\r
  if ((Data & UFS_HC_IS_UCCS) == UFS_HC_IS_UCCS) {\r
    //\r
    // Clear IS.BIT10 UIC Command Completion Status (UCCS) at first.\r
    //\r
    MmioWrite32 (Address, Data);\r
  }\r
\r
  //\r
  // When programming UIC command registers, host software shall set the register UICCMD\r
  // only after all the UIC command argument registers (UICCMDARG1, UICCMDARG2 and UICCMDARG3)\r
  // are set.\r
  //\r
  Address = UfsHcBase + UFS_HC_UCMD_ARG1_OFFSET;\r
  MmioWrite32 (Address, Arg1);\r
\r
  Address = UfsHcBase + UFS_HC_UCMD_ARG2_OFFSET;\r
  MmioWrite32 (Address, Arg2);\r
\r
  Address = UfsHcBase + UFS_HC_UCMD_ARG3_OFFSET;\r
  MmioWrite32 (Address, Arg3);\r
\r
  //\r
  // Host software shall only set the UICCMD if HCS.UCRDY is set to 1.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_STATUS_OFFSET;\r
  Status  = UfsWaitMemSet (Address, UFS_HC_HCS_UCRDY, UFS_HC_HCS_UCRDY, UFS_TIMEOUT);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Address = UfsHcBase + UFS_HC_UIC_CMD_OFFSET;\r
  MmioWrite32 (Address, (UINT32)UicOpcode);\r
\r
  //\r
  // UFS 2.0 spec section 5.3.1 Offset:0x20 IS.Bit10 UIC Command Completion Status (UCCS)\r
  // This bit is set to '1' by the host controller upon completion of a UIC command.\r
  //\r
  Address = UfsHcBase + UFS_HC_IS_OFFSET;\r
  Data    = MmioRead32 (Address);\r
  Status  = UfsWaitMemSet (Address, UFS_HC_IS_UCCS, UFS_HC_IS_UCCS, UFS_TIMEOUT);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (UicOpcode != UfsUicDmeReset) {\r
    Address = UfsHcBase + UFS_HC_UCMD_ARG2_OFFSET;\r
    Data    = MmioRead32 (Address);\r
    if ((Data & 0xFF) != 0) {\r
      DEBUG_CODE_BEGIN ();\r
      DumpUicCmdExecResult (UicOpcode, (UINT8)(Data & 0xFF));\r
      DEBUG_CODE_END ();\r
      return EFI_DEVICE_ERROR;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Enable the UFS host controller for accessing.\r
\r
  @param[in] Private                 The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
\r
  @retval EFI_SUCCESS                The UFS host controller enabling was executed successfully.\r
  @retval EFI_DEVICE_ERROR           A device error occurred while enabling the UFS host controller.\r
\r
**/\r
EFI_STATUS\r
UfsEnableHostController (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Address;\r
  UINT32      Data;\r
\r
  //\r
  // UFS 2.0 spec section 7.1.1 - Host Controller Initialization\r
  //\r
  // Reinitialize the UFS host controller if HCE bit of HC register is set.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_ENABLE_OFFSET;\r
  Data    = MmioRead32 (Address);\r
  if ((Data & UFS_HC_HCE_EN) == UFS_HC_HCE_EN) {\r
    //\r
    // Write a 0 to the HCE register at first to disable the host controller.\r
    //\r
    MmioWrite32 (Address, 0);\r
    //\r
    // Wait until HCE is read as '0' before continuing.\r
    //\r
    Status = UfsWaitMemSet (Address, UFS_HC_HCE_EN, 0, UFS_TIMEOUT);\r
    if (EFI_ERROR (Status)) {\r
      return EFI_DEVICE_ERROR;\r
    }\r
  }\r
\r
  //\r
  // Write a 1 to the HCE register to enable the UFS host controller.\r
  //\r
  MmioWrite32 (Address, UFS_HC_HCE_EN);\r
  //\r
  // Wait until HCE is read as '1' before continuing.\r
  //\r
  Status = UfsWaitMemSet (Address, UFS_HC_HCE_EN, UFS_HC_HCE_EN, UFS_TIMEOUT);\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Detect if a UFS device attached.\r
\r
  @param[in] Private                 The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
\r
  @retval EFI_SUCCESS                The UFS device detection was executed successfully.\r
  @retval EFI_NOT_FOUND              Not found a UFS device attached.\r
  @retval EFI_DEVICE_ERROR           A device error occurred while detecting the UFS device.\r
\r
**/\r
EFI_STATUS\r
UfsDeviceDetection (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private\r
  )\r
{\r
  UINTN       Retry;\r
  UINTN       Address;\r
  UINT32      Data;\r
  EFI_STATUS  Status;\r
\r
  //\r
  // Start UFS device detection.\r
  // Try up to 3 times for establishing data link with device.\r
  //\r
  for (Retry = 0; Retry < 3; Retry++) {\r
    Status = UfsExecUicCommands (Private, UfsUicDmeLinkStartup, 0, 0, 0);\r
    if (EFI_ERROR (Status)) {\r
      return EFI_DEVICE_ERROR;\r
    }\r
\r
    //\r
    // Check value of HCS.DP and make sure that there is a device attached to the Link\r
    //\r
    Address = Private->UfsHcBase + UFS_HC_STATUS_OFFSET;\r
    Data    = MmioRead32 (Address);\r
    if ((Data & UFS_HC_HCS_DP) == 0) {\r
      Address = Private->UfsHcBase + UFS_HC_IS_OFFSET;\r
      Status  = UfsWaitMemSet (Address, UFS_HC_IS_ULSS, UFS_HC_IS_ULSS, UFS_TIMEOUT);\r
      if (EFI_ERROR (Status)) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
    } else {\r
      DEBUG ((DEBUG_INFO, "UfsblockioPei: found a attached UFS device\n"));\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
/**\r
  Initialize UFS task management request list related h/w context.\r
\r
  @param[in] Private                 The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
\r
  @retval EFI_SUCCESS                The UFS task management list was initialzed successfully.\r
  @retval EFI_DEVICE_ERROR           The initialization fails.\r
\r
**/\r
EFI_STATUS\r
UfsInitTaskManagementRequestList (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private\r
  )\r
{\r
  UINTN                 Address;\r
  UINT32                Data;\r
  UINT8                 Nutmrs;\r
  VOID                  *CmdDescHost;\r
  EFI_PHYSICAL_ADDRESS  CmdDescPhyAddr;\r
  VOID                  *CmdDescMapping;\r
  EFI_STATUS            Status;\r
\r
  //\r
  // Initial h/w and s/w context for future operations.\r
  //\r
  Address               = Private->UfsHcBase + UFS_HC_CAP_OFFSET;\r
  Data                  = MmioRead32 (Address);\r
  Private->Capabilities = Data;\r
\r
  //\r
  // Allocate and initialize UTP Task Management Request List.\r
  //\r
  Nutmrs = (UINT8)(RShiftU64 ((Private->Capabilities & UFS_HC_CAP_NUTMRS), 16) + 1);\r
  Status = IoMmuAllocateBuffer (\r
             EFI_SIZE_TO_PAGES (Nutmrs * sizeof (UTP_TMRD)),\r
             &CmdDescHost,\r
             &CmdDescPhyAddr,\r
             &CmdDescMapping\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  ZeroMem (CmdDescHost, EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Nutmrs * sizeof (UTP_TMRD))));\r
\r
  //\r
  // Program the UTP Task Management Request List Base Address and UTP Task Management\r
  // Request List Base Address with a 64-bit address allocated at step 6.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTMRLBA_OFFSET;\r
  MmioWrite32 (Address, (UINT32)(UINTN)CmdDescPhyAddr);\r
  Address = Private->UfsHcBase + UFS_HC_UTMRLBAU_OFFSET;\r
  MmioWrite32 (Address, (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 32));\r
  Private->UtpTmrlBase = (VOID *)(UINTN)CmdDescHost;\r
  Private->Nutmrs      = Nutmrs;\r
  Private->TmrlMapping = CmdDescMapping;\r
\r
  //\r
  // Enable the UTP Task Management Request List by setting the UTP Task Management\r
  // Request List RunStop Register (UTMRLRSR) to '1'.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTMRLRSR_OFFSET;\r
  MmioWrite32 (Address, UFS_HC_UTMRLRSR);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Initialize UFS transfer request list related h/w context.\r
\r
  @param[in] Private                 The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
\r
  @retval EFI_SUCCESS                The UFS transfer list was initialzed successfully.\r
  @retval EFI_DEVICE_ERROR           The initialization fails.\r
\r
**/\r
EFI_STATUS\r
UfsInitTransferRequestList (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private\r
  )\r
{\r
  UINTN                 Address;\r
  UINT32                Data;\r
  UINT8                 Nutrs;\r
  VOID                  *CmdDescHost;\r
  EFI_PHYSICAL_ADDRESS  CmdDescPhyAddr;\r
  VOID                  *CmdDescMapping;\r
  EFI_STATUS            Status;\r
\r
  //\r
  // Initial h/w and s/w context for future operations.\r
  //\r
  Address               = Private->UfsHcBase + UFS_HC_CAP_OFFSET;\r
  Data                  = MmioRead32 (Address);\r
  Private->Capabilities = Data;\r
\r
  //\r
  // Allocate and initialize UTP Transfer Request List.\r
  //\r
  Nutrs  = (UINT8)((Private->Capabilities & UFS_HC_CAP_NUTRS) + 1);\r
  Status = IoMmuAllocateBuffer (\r
             EFI_SIZE_TO_PAGES (Nutrs * sizeof (UTP_TRD)),\r
             &CmdDescHost,\r
             &CmdDescPhyAddr,\r
             &CmdDescMapping\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  ZeroMem (CmdDescHost, EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Nutrs * sizeof (UTP_TRD))));\r
\r
  //\r
  // Program the UTP Transfer Request List Base Address and UTP Transfer Request List\r
  // Base Address with a 64-bit address allocated at step 8.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTRLBA_OFFSET;\r
  MmioWrite32 (Address, (UINT32)(UINTN)CmdDescPhyAddr);\r
  Address = Private->UfsHcBase + UFS_HC_UTRLBAU_OFFSET;\r
  MmioWrite32 (Address, (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 32));\r
  Private->UtpTrlBase = (VOID *)(UINTN)CmdDescHost;\r
  Private->Nutrs      = Nutrs;\r
  Private->TrlMapping = CmdDescMapping;\r
\r
  //\r
  // Enable the UTP Transfer Request List by setting the UTP Transfer Request List\r
  // RunStop Register (UTRLRSR) to '1'.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTRLRSR_OFFSET;\r
  MmioWrite32 (Address, UFS_HC_UTRLRSR);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Initialize the UFS host controller.\r
\r
  @param[in] Private                 The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
\r
  @retval EFI_SUCCESS                The Ufs Host Controller is initialized successfully.\r
  @retval Others                     A device error occurred while initializing the controller.\r
\r
**/\r
EFI_STATUS\r
UfsControllerInit (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = UfsEnableHostController (Private);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "UfsDevicePei: Enable Host Controller Fails, Status = %r\n", Status));\r
    return Status;\r
  }\r
\r
  Status = UfsDeviceDetection (Private);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "UfsDevicePei: Device Detection Fails, Status = %r\n", Status));\r
    return Status;\r
  }\r
\r
  Status = UfsInitTaskManagementRequestList (Private);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "UfsDevicePei: Task management list initialization Fails, Status = %r\n", Status));\r
    return Status;\r
  }\r
\r
  Status = UfsInitTransferRequestList (Private);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "UfsDevicePei: Transfer list initialization Fails, Status = %r\n", Status));\r
\r
    if (Private->TmrlMapping != NULL) {\r
      IoMmuFreeBuffer (\r
        EFI_SIZE_TO_PAGES (Private->Nutmrs * sizeof (UTP_TMRD)),\r
        Private->UtpTmrlBase,\r
        Private->TmrlMapping\r
        );\r
      Private->TmrlMapping = NULL;\r
    }\r
\r
    return Status;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "UfsDevicePei Finished\n"));\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Stop the UFS host controller.\r
\r
  @param[in] Private                 The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure.\r
\r
  @retval EFI_SUCCESS                The Ufs Host Controller is stopped successfully.\r
  @retval Others                     A device error occurred while stopping the controller.\r
\r
**/\r
EFI_STATUS\r
UfsControllerStop (\r
  IN  UFS_PEIM_HC_PRIVATE_DATA  *Private\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Address;\r
  UINT32      Data;\r
\r
  //\r
  // Enable the UTP Task Management Request List by setting the UTP Task Management\r
  // Request List RunStop Register (UTMRLRSR) to '1'.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTMRLRSR_OFFSET;\r
  MmioWrite32 (Address, 0);\r
\r
  //\r
  // Enable the UTP Transfer Request List by setting the UTP Transfer Request List\r
  // RunStop Register (UTRLRSR) to '1'.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_UTRLRSR_OFFSET;\r
  MmioWrite32 (Address, 0);\r
\r
  //\r
  // Write a 0 to the HCE register in order to disable the host controller.\r
  //\r
  Address = Private->UfsHcBase + UFS_HC_ENABLE_OFFSET;\r
  Data    = MmioRead32 (Address);\r
  ASSERT ((Data & UFS_HC_HCE_EN) == UFS_HC_HCE_EN);\r
  MmioWrite32 (Address, 0);\r
\r
  //\r
  // Wait until HCE is read as '0' before continuing.\r
  //\r
  Status = UfsWaitMemSet (Address, UFS_HC_HCE_EN, 0, UFS_TIMEOUT);\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "UfsDevicePei: Stop the UFS Host Controller\n"));\r
\r
  return EFI_SUCCESS;\r
}\r