UfsBlockIoPei.c

Go to the documentation of this file.

 
#include "UfsBlockIoPei.h"
 
//
// Template for UFS HC Peim Private Data.
//
UFS_PEIM_HC_PRIVATE_DATA  gUfsHcPeimTemplate = {
  UFS_PEIM_HC_SIG,                // Signature
  NULL,                           // Controller
  NULL,                           // Pool
  {                               // BlkIoPpi
    UfsBlockIoPeimGetDeviceNo,
    UfsBlockIoPeimGetMediaInfo,
    UfsBlockIoPeimReadBlocks
  },
  {                               // BlkIo2Ppi
    EFI_PEI_RECOVERY_BLOCK_IO2_PPI_REVISION,
    UfsBlockIoPeimGetDeviceNo2,
    UfsBlockIoPeimGetMediaInfo2,
    UfsBlockIoPeimReadBlocks2
  },
  {                               // BlkIoPpiList
    EFI_PEI_PPI_DESCRIPTOR_PPI,
    &gEfiPeiVirtualBlockIoPpiGuid,
    NULL
  },
  {                               // BlkIo2PpiList
    EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
    &gEfiPeiVirtualBlockIo2PpiGuid,
    NULL
  },
  {                               // Media
    {
      MSG_UFS_DP,
      FALSE,
      TRUE,
      FALSE,
      0x1000,
      0
    },
    {
      MSG_UFS_DP,
      FALSE,
      TRUE,
      FALSE,
      0x1000,
      0
    },
    {
      MSG_UFS_DP,
      FALSE,
      TRUE,
      FALSE,
      0x1000,
      0
    },
    {
      MSG_UFS_DP,
      FALSE,
      TRUE,
      FALSE,
      0x1000,
      0
    },
    {
      MSG_UFS_DP,
      FALSE,
      TRUE,
      FALSE,
      0x1000,
      0
    },
    {
      MSG_UFS_DP,
      FALSE,
      TRUE,
      FALSE,
      0x1000,
      0
    },
    {
      MSG_UFS_DP,
      FALSE,
      TRUE,
      FALSE,
      0x1000,
      0
    },
    {
      MSG_UFS_DP,
      FALSE,
      TRUE,
      FALSE,
      0x1000,
      0
    }
  },
  {                               // EndOfPeiNotifyList
    (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
    &gEfiEndOfPeiSignalPpiGuid,
    UfsEndOfPei
  },
  0,                              // UfsHcBase
  0,                              // Capabilities
  0,                              // TaskTag
  0,                              // UtpTrlBase
  0,                              // Nutrs
  NULL,                           // TrlMapping
  0,                              // UtpTmrlBase
  0,                              // Nutmrs
  NULL,                           // TmrlMapping
  {                               // Luns
    {
      UFS_LUN_0,                      // Ufs Common Lun 0
      UFS_LUN_1,                      // Ufs Common Lun 1
      UFS_LUN_2,                      // Ufs Common Lun 2
      UFS_LUN_3,                      // Ufs Common Lun 3
      UFS_LUN_4,                      // Ufs Common Lun 4
      UFS_LUN_5,                      // Ufs Common Lun 5
      UFS_LUN_6,                      // Ufs Common Lun 6
      UFS_LUN_7,                      // Ufs Common Lun 7
    },
    0x0000,                           // By default exposing all Luns.
    0x0
  }
};
 
EFI_STATUS
UfsPeimTestUnitReady (
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,
  IN     UINTN                     Lun,
  OUT VOID                         *SenseData   OPTIONAL,
  OUT UINT8                        *SenseDataLength
  )
{
  UFS_SCSI_REQUEST_PACKET  Packet;
  UINT8                    Cdb[UFS_SCSI_OP_LENGTH_SIX];
  EFI_STATUS               Status;
 
  ZeroMem (&Packet, sizeof (UFS_SCSI_REQUEST_PACKET));
  ZeroMem (Cdb, sizeof (Cdb));
 
  Cdb[0] = EFI_SCSI_OP_TEST_UNIT_READY;
 
  Packet.Timeout         = UFS_TIMEOUT;
  Packet.Cdb             = Cdb;
  Packet.CdbLength       = sizeof (Cdb);
  Packet.DataDirection   = UfsNoData;
  Packet.SenseData       = SenseData;
  Packet.SenseDataLength = *SenseDataLength;
 
  Status = UfsExecScsiCmds (Private, (UINT8)Lun, &Packet);
 
  if (*SenseDataLength != 0) {
    *SenseDataLength = Packet.SenseDataLength;
  }
 
  return Status;
}
 
EFI_STATUS
UfsPeimReadCapacity (
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,
  IN     UINTN                     Lun,
  OUT VOID                         *DataBuffer,
  OUT UINT32                       *DataLength,
  OUT VOID                         *SenseData   OPTIONAL,
  OUT UINT8                        *SenseDataLength
  )
{
  UFS_SCSI_REQUEST_PACKET  Packet;
  UINT8                    Cdb[UFS_SCSI_OP_LENGTH_TEN];
  EFI_STATUS               Status;
 
  ZeroMem (&Packet, sizeof (UFS_SCSI_REQUEST_PACKET));
  ZeroMem (Cdb, sizeof (Cdb));
 
  Cdb[0] = EFI_SCSI_OP_READ_CAPACITY;
 
  Packet.Timeout          = UFS_TIMEOUT;
  Packet.Cdb              = Cdb;
  Packet.CdbLength        = sizeof (Cdb);
  Packet.InDataBuffer     = DataBuffer;
  Packet.InTransferLength = *DataLength;
  Packet.DataDirection    = UfsDataIn;
  Packet.SenseData        = SenseData;
  Packet.SenseDataLength  = *SenseDataLength;
 
  Status = UfsExecScsiCmds (Private, (UINT8)Lun, &Packet);
 
  if (*SenseDataLength != 0) {
    *SenseDataLength = Packet.SenseDataLength;
  }
 
  if (!EFI_ERROR (Status)) {
    *DataLength = Packet.InTransferLength;
  }
 
  return Status;
}
 
EFI_STATUS
UfsPeimReadCapacity16 (
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,
  IN     UINTN                     Lun,
  OUT VOID                         *DataBuffer,
  OUT UINT32                       *DataLength,
  OUT VOID                         *SenseData   OPTIONAL,
  OUT UINT8                        *SenseDataLength
  )
{
  UFS_SCSI_REQUEST_PACKET  Packet;
  UINT8                    Cdb[UFS_SCSI_OP_LENGTH_SIXTEEN];
  EFI_STATUS               Status;
 
  ZeroMem (&Packet, sizeof (UFS_SCSI_REQUEST_PACKET));
  ZeroMem (Cdb, sizeof (Cdb));
 
  Cdb[0]  = EFI_SCSI_OP_READ_CAPACITY16;
  Cdb[1]  = 0x10;          // Service Action should be 0x10 for UFS device.
  Cdb[13] = 0x20;          // The maximum number of bytes for returned data.
 
  Packet.Timeout          = UFS_TIMEOUT;
  Packet.Cdb              = Cdb;
  Packet.CdbLength        = sizeof (Cdb);
  Packet.InDataBuffer     = DataBuffer;
  Packet.InTransferLength = *DataLength;
  Packet.DataDirection    = UfsDataIn;
  Packet.SenseData        = SenseData;
  Packet.SenseDataLength  = *SenseDataLength;
 
  Status = UfsExecScsiCmds (Private, (UINT8)Lun, &Packet);
 
  if (*SenseDataLength != 0) {
    *SenseDataLength = Packet.SenseDataLength;
  }
 
  if (!EFI_ERROR (Status)) {
    *DataLength = Packet.InTransferLength;
  }
 
  return Status;
}
 
EFI_STATUS
UfsPeimRead10 (
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,
  IN     UINTN                     Lun,
  IN     UINTN                     StartLba,
  IN     UINT32                    SectorNum,
  OUT VOID                         *DataBuffer,
  OUT UINT32                       *DataLength,
  OUT VOID                         *SenseData   OPTIONAL,
  OUT UINT8                        *SenseDataLength
  )
{
  UFS_SCSI_REQUEST_PACKET  Packet;
  UINT8                    Cdb[UFS_SCSI_OP_LENGTH_TEN];
  EFI_STATUS               Status;
 
  ZeroMem (&Packet, sizeof (UFS_SCSI_REQUEST_PACKET));
  ZeroMem (Cdb, sizeof (Cdb));
 
  Cdb[0] = EFI_SCSI_OP_READ10;
  WriteUnaligned32 ((UINT32 *)&Cdb[2], SwapBytes32 ((UINT32)StartLba));
  WriteUnaligned16 ((UINT16 *)&Cdb[7], SwapBytes16 ((UINT16)SectorNum));
 
  Packet.Timeout          = UFS_TIMEOUT;
  Packet.Cdb              = Cdb;
  Packet.CdbLength        = sizeof (Cdb);
  Packet.InDataBuffer     = DataBuffer;
  Packet.InTransferLength = *DataLength;
  Packet.DataDirection    = UfsDataIn;
  Packet.SenseData        = SenseData;
  Packet.SenseDataLength  = *SenseDataLength;
 
  Status = UfsExecScsiCmds (Private, (UINT8)Lun, &Packet);
 
  if (*SenseDataLength != 0) {
    *SenseDataLength = Packet.SenseDataLength;
  }
 
  if (!EFI_ERROR (Status)) {
    *DataLength = Packet.InTransferLength;
  }
 
  return Status;
}
 
EFI_STATUS
UfsPeimRead16 (
  IN     UFS_PEIM_HC_PRIVATE_DATA  *Private,
  IN     UINTN                     Lun,
  IN     UINTN                     StartLba,
  IN     UINT32                    SectorNum,
  OUT VOID                         *DataBuffer,
  OUT UINT32                       *DataLength,
  OUT VOID                         *SenseData   OPTIONAL,
  OUT UINT8                        *SenseDataLength
  )
{
  UFS_SCSI_REQUEST_PACKET  Packet;
  UINT8                    Cdb[UFS_SCSI_OP_LENGTH_SIXTEEN];
  EFI_STATUS               Status;
 
  ZeroMem (&Packet, sizeof (UFS_SCSI_REQUEST_PACKET));
  ZeroMem (Cdb, sizeof (Cdb));
 
  Cdb[0] = EFI_SCSI_OP_READ16;
  WriteUnaligned64 ((UINT64 *)&Cdb[2], SwapBytes64 (StartLba));
  WriteUnaligned32 ((UINT32 *)&Cdb[10], SwapBytes32 (SectorNum));
 
  Packet.Timeout          = UFS_TIMEOUT;
  Packet.Cdb              = Cdb;
  Packet.CdbLength        = sizeof (Cdb);
  Packet.InDataBuffer     = DataBuffer;
  Packet.InTransferLength = *DataLength;
  Packet.DataDirection    = UfsDataIn;
  Packet.SenseData        = SenseData;
  Packet.SenseDataLength  = *SenseDataLength;
 
  Status = UfsExecScsiCmds (Private, (UINT8)Lun, &Packet);
 
  if (*SenseDataLength != 0) {
    *SenseDataLength = Packet.SenseDataLength;
  }
 
  if (!EFI_ERROR (Status)) {
    *DataLength = Packet.InTransferLength;
  }
 
  return Status;
}
 
EFI_STATUS
UfsPeimParsingSenseKeys (
  IN     EFI_PEI_BLOCK_IO2_MEDIA  *Media,
  IN     EFI_SCSI_SENSE_DATA      *SenseData,
  OUT BOOLEAN                     *NeedRetry
  )
{
  if ((SenseData->Sense_Key == EFI_SCSI_SK_NOT_READY) &&
      (SenseData->Addnl_Sense_Code == EFI_SCSI_ASC_NO_MEDIA))
  {
    Media->MediaPresent = FALSE;
    *NeedRetry          = FALSE;
    DEBUG ((DEBUG_VERBOSE, "UfsBlockIoPei: Is No Media\n"));
    return EFI_DEVICE_ERROR;
  }
 
  if ((SenseData->Sense_Key == EFI_SCSI_SK_UNIT_ATTENTION) &&
      (SenseData->Addnl_Sense_Code == EFI_SCSI_ASC_MEDIA_CHANGE))
  {
    *NeedRetry = TRUE;
    DEBUG ((DEBUG_VERBOSE, "UfsBlockIoPei: Is Media Change\n"));
    return EFI_SUCCESS;
  }
 
  if ((SenseData->Sense_Key == EFI_SCSI_SK_UNIT_ATTENTION) &&
      (SenseData->Addnl_Sense_Code == EFI_SCSI_ASC_RESET))
  {
    *NeedRetry = TRUE;
    DEBUG ((DEBUG_VERBOSE, "UfsBlockIoPei: Was Reset Before\n"));
    return EFI_SUCCESS;
  }
 
  if ((SenseData->Sense_Key == EFI_SCSI_SK_MEDIUM_ERROR) ||
      ((SenseData->Sense_Key == EFI_SCSI_SK_NOT_READY) &&
       (SenseData->Addnl_Sense_Code == EFI_SCSI_ASC_MEDIA_UPSIDE_DOWN)))
  {
    *NeedRetry = FALSE;
    DEBUG ((DEBUG_VERBOSE, "UfsBlockIoPei: Media Error\n"));
    return EFI_DEVICE_ERROR;
  }
 
  if (SenseData->Sense_Key == EFI_SCSI_SK_HARDWARE_ERROR) {
    *NeedRetry = FALSE;
    DEBUG ((DEBUG_VERBOSE, "UfsBlockIoPei: Hardware Error\n"));
    return EFI_DEVICE_ERROR;
  }
 
  if ((SenseData->Sense_Key == EFI_SCSI_SK_NOT_READY) &&
      (SenseData->Addnl_Sense_Code == EFI_SCSI_ASC_NOT_READY) &&
      (SenseData->Addnl_Sense_Code_Qualifier == EFI_SCSI_ASCQ_IN_PROGRESS))
  {
    *NeedRetry = TRUE;
    DEBUG ((DEBUG_VERBOSE, "UfsBlockIoPei: Was Reset Before\n"));
    return EFI_SUCCESS;
  }
 
  *NeedRetry = FALSE;
  DEBUG ((DEBUG_VERBOSE, "UfsBlockIoPei: Sense Key = 0x%x ASC = 0x%x!\n", SenseData->Sense_Key, SenseData->Addnl_Sense_Code));
  return EFI_DEVICE_ERROR;
}
 
EFI_STATUS
EFIAPI
UfsBlockIoPeimGetDeviceNo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  OUT UINTN                          *NumberBlockDevices
  )
{
  //
  // For Ufs device, it has up to 8 normal Luns plus some well-known Luns.
  // At PEI phase, we will only expose normal Luns to user.
  // For those disabled Lun, when user try to access it, the operation would fail.
  //
  *NumberBlockDevices = UFS_PEIM_MAX_LUNS;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
UfsBlockIoPeimGetMediaInfo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  IN  UINTN                          DeviceIndex,
  OUT EFI_PEI_BLOCK_IO_MEDIA         *MediaInfo
  )
{
  EFI_STATUS                     Status;
  UFS_PEIM_HC_PRIVATE_DATA       *Private;
  EFI_SCSI_SENSE_DATA            SenseData;
  UINT8                          SenseDataLength;
  EFI_SCSI_DISK_CAPACITY_DATA    Capacity;
  EFI_SCSI_DISK_CAPACITY_DATA16  Capacity16;
  UINTN                          DataLength;
  BOOLEAN                        NeedRetry;
  UINTN                          Lun;
 
  Private   = GET_UFS_PEIM_HC_PRIVATE_DATA_FROM_THIS (This);
  NeedRetry = TRUE;
 
  if ((DeviceIndex == 0) || (DeviceIndex > UFS_PEIM_MAX_LUNS)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Lun = DeviceIndex - 1;
  if ((Private->Luns.BitMask & (BIT0 << Lun)) == 0) {
    return EFI_ACCESS_DENIED;
  }
 
  ZeroMem (&SenseData, sizeof (SenseData));
  ZeroMem (&Capacity, sizeof (Capacity));
  ZeroMem (&Capacity16, sizeof (Capacity16));
  SenseDataLength = sizeof (SenseData);
  //
  // First test unit ready
  //
  do {
    Status = UfsPeimTestUnitReady (
               Private,
               Lun,
               &SenseData,
               &SenseDataLength
               );
    if (!EFI_ERROR (Status)) {
      break;
    }
 
    if (SenseDataLength == 0) {
      continue;
    }
 
    Status = UfsPeimParsingSenseKeys (&(Private->Media[Lun]), &SenseData, &NeedRetry);
    if (EFI_ERROR (Status)) {
      return EFI_DEVICE_ERROR;
    }
  } while (NeedRetry);
 
  DataLength      = sizeof (EFI_SCSI_DISK_CAPACITY_DATA);
  SenseDataLength = 0;
  Status          = UfsPeimReadCapacity (Private, Lun, &Capacity, (UINT32 *)&DataLength, NULL, &SenseDataLength);
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  if ((Capacity.LastLba3 == 0xff) && (Capacity.LastLba2 == 0xff) &&
      (Capacity.LastLba1 == 0xff) && (Capacity.LastLba0 == 0xff))
  {
    DataLength      = sizeof (EFI_SCSI_DISK_CAPACITY_DATA16);
    SenseDataLength = 0;
    Status          = UfsPeimReadCapacity16 (Private, Lun, &Capacity16, (UINT32 *)&DataLength, NULL, &SenseDataLength);
    if (EFI_ERROR (Status)) {
      return EFI_DEVICE_ERROR;
    }
 
    Private->Media[Lun].LastBlock  = ((UINT32)Capacity16.LastLba3 << 24) | (Capacity16.LastLba2 << 16) | (Capacity16.LastLba1 << 8) | Capacity16.LastLba0;
    Private->Media[Lun].LastBlock |= LShiftU64 ((UINT64)Capacity16.LastLba7, 56) | LShiftU64 ((UINT64)Capacity16.LastLba6, 48) | LShiftU64 ((UINT64)Capacity16.LastLba5, 40) | LShiftU64 ((UINT64)Capacity16.LastLba4, 32);
    Private->Media[Lun].BlockSize  = (Capacity16.BlockSize3 << 24) | (Capacity16.BlockSize2 << 16) | (Capacity16.BlockSize1 << 8) | Capacity16.BlockSize0;
  } else {
    Private->Media[Lun].LastBlock = ((UINT32)Capacity.LastLba3 << 24) | (Capacity.LastLba2 << 16) | (Capacity.LastLba1 << 8) | Capacity.LastLba0;
    Private->Media[Lun].BlockSize = (Capacity.BlockSize3 << 24) | (Capacity.BlockSize2 << 16) | (Capacity.BlockSize1 << 8) | Capacity.BlockSize0;
  }
 
  MediaInfo->DeviceType   = UfsDevice;
  MediaInfo->MediaPresent = Private->Media[Lun].MediaPresent;
  MediaInfo->LastBlock    = (UINTN)Private->Media[Lun].LastBlock;
  MediaInfo->BlockSize    = Private->Media[Lun].BlockSize;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
UfsBlockIoPeimReadBlocks (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  IN  UINTN                          DeviceIndex,
  IN  EFI_PEI_LBA                    StartLBA,
  IN  UINTN                          BufferSize,
  OUT VOID                           *Buffer
  )
{
  EFI_STATUS                Status;
  UINTN                     BlockSize;
  UINTN                     NumberOfBlocks;
  UFS_PEIM_HC_PRIVATE_DATA  *Private;
  EFI_SCSI_SENSE_DATA       SenseData;
  UINT8                     SenseDataLength;
  BOOLEAN                   NeedRetry;
  UINTN                     Lun;
 
  Status    = EFI_SUCCESS;
  NeedRetry = TRUE;
  Private   = GET_UFS_PEIM_HC_PRIVATE_DATA_FROM_THIS (This);
 
  ZeroMem (&SenseData, sizeof (SenseData));
  SenseDataLength = sizeof (SenseData);
 
  //
  // Check parameters
  //
  if (Buffer == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (BufferSize == 0) {
    return EFI_SUCCESS;
  }
 
  if ((DeviceIndex == 0) || (DeviceIndex > UFS_PEIM_MAX_LUNS)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Lun = DeviceIndex - 1;
  if ((Private->Luns.BitMask & (BIT0 << Lun)) == 0) {
    return EFI_ACCESS_DENIED;
  }
 
  BlockSize = Private->Media[Lun].BlockSize;
 
  if (BufferSize % BlockSize != 0) {
    Status = EFI_BAD_BUFFER_SIZE;
  }
 
  if (StartLBA > Private->Media[Lun].LastBlock) {
    Status = EFI_INVALID_PARAMETER;
  }
 
  NumberOfBlocks = BufferSize / BlockSize;
 
  do {
    Status = UfsPeimTestUnitReady (
               Private,
               Lun,
               &SenseData,
               &SenseDataLength
               );
    if (!EFI_ERROR (Status)) {
      break;
    }
 
    if (SenseDataLength == 0) {
      continue;
    }
 
    Status = UfsPeimParsingSenseKeys (&(Private->Media[Lun]), &SenseData, &NeedRetry);
    if (EFI_ERROR (Status)) {
      return EFI_DEVICE_ERROR;
    }
  } while (NeedRetry);
 
  SenseDataLength = 0;
  if (Private->Media[Lun].LastBlock < 0xfffffffful) {
    Status = UfsPeimRead10 (
               Private,
               Lun,
               (UINT32)StartLBA,
               (UINT32)NumberOfBlocks,
               Buffer,
               (UINT32 *)&BufferSize,
               NULL,
               &SenseDataLength
               );
  } else {
    Status = UfsPeimRead16 (
               Private,
               Lun,
               (UINT32)StartLBA,
               (UINT32)NumberOfBlocks,
               Buffer,
               (UINT32 *)&BufferSize,
               NULL,
               &SenseDataLength
               );
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
UfsBlockIoPeimGetDeviceNo2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  OUT UINTN                           *NumberBlockDevices
  )
{
  //
  // For Ufs device, it has up to 8 normal Luns plus some well-known Luns.
  // At PEI phase, we will only expose normal Luns to user.
  // For those disabled Lun, when user try to access it, the operation would fail.
  //
  *NumberBlockDevices = UFS_PEIM_MAX_LUNS;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
UfsBlockIoPeimGetMediaInfo2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  IN  UINTN                           DeviceIndex,
  OUT EFI_PEI_BLOCK_IO2_MEDIA         *MediaInfo
  )
{
  EFI_STATUS                Status;
  UFS_PEIM_HC_PRIVATE_DATA  *Private;
  EFI_PEI_BLOCK_IO_MEDIA    Media;
  UINTN                     Lun;
 
  Private = GET_UFS_PEIM_HC_PRIVATE_DATA_FROM_THIS2 (This);
 
  Status = UfsBlockIoPeimGetMediaInfo (
             PeiServices,
             &Private->BlkIoPpi,
             DeviceIndex,
             &Media
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Lun = DeviceIndex - 1;
  CopyMem (MediaInfo, &(Private->Media[Lun]), sizeof (EFI_PEI_BLOCK_IO2_MEDIA));
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
UfsBlockIoPeimReadBlocks2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  IN  UINTN                           DeviceIndex,
  IN  EFI_PEI_LBA                     StartLBA,
  IN  UINTN                           BufferSize,
  OUT VOID                            *Buffer
  )
{
  EFI_STATUS                Status;
  UFS_PEIM_HC_PRIVATE_DATA  *Private;
 
  Status  = EFI_SUCCESS;
  Private = GET_UFS_PEIM_HC_PRIVATE_DATA_FROM_THIS2 (This);
 
  Status = UfsBlockIoPeimReadBlocks (
             PeiServices,
             &Private->BlkIoPpi,
             DeviceIndex,
             StartLBA,
             BufferSize,
             Buffer
             );
  return Status;
}
 
EFI_STATUS
EFIAPI
UfsEndOfPei (
  IN EFI_PEI_SERVICES           **PeiServices,
  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
  IN VOID                       *Ppi
  )
{
  UFS_PEIM_HC_PRIVATE_DATA  *Private;
 
  Private = GET_UFS_PEIM_HC_PRIVATE_DATA_FROM_THIS_NOTIFY (NotifyDescriptor);
 
  if ((Private->Pool != NULL) && (Private->Pool->Head != NULL)) {
    UfsPeimFreeMemPool (Private->Pool);
  }
 
  if (Private->UtpTmrlBase != NULL) {
    IoMmuFreeBuffer (
      EFI_SIZE_TO_PAGES (Private->Nutmrs * sizeof (UTP_TMRD)),
      Private->UtpTmrlBase,
      Private->TmrlMapping
      );
  }
 
  if (Private->UtpTrlBase != NULL) {
    IoMmuFreeBuffer (
      EFI_SIZE_TO_PAGES (Private->Nutrs * sizeof (UTP_TRD)),
      Private->UtpTrlBase,
      Private->TrlMapping
      );
  }
 
  UfsControllerStop (Private);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
UfsFinishDeviceInitialization (
  IN UFS_PEIM_HC_PRIVATE_DATA  *Private
  )
{
  EFI_STATUS  Status;
  UINT8       DeviceInitStatus;
  UINT32      Timeout;
 
  DeviceInitStatus = 0xFF;
  Timeout          = PcdGet32 (PcdUfsInitialCompletionTimeout);
 
  //
  // The host enables the device initialization completion by setting fDeviceInit flag.
  //
  Status = UfsSetFlag (Private, UfsFlagDevInit);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  do {
    Status = UfsReadFlag (Private, UfsFlagDevInit, &DeviceInitStatus);
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    MicroSecondDelay (1);
    Timeout--;
  } while (DeviceInitStatus != 0 && Timeout != 0);
 
  if (Timeout == 0) {
    DEBUG ((DEBUG_ERROR, "%a: DeviceInitStatus = %x EFI_TIMEOUT \n", __func__, DeviceInitStatus));
    return EFI_TIMEOUT;
  } else {
    DEBUG ((DEBUG_INFO, "%a: Timeout left = %x EFI_SUCCESS \n", __func__, Timeout));
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
EFIAPI
InitializeUfsBlockIoPeim (
  IN EFI_PEI_FILE_HANDLE     FileHandle,
  IN CONST EFI_PEI_SERVICES  **PeiServices
  )
{
  EFI_STATUS                             Status;
  UFS_PEIM_HC_PRIVATE_DATA               *Private;
  EDKII_UFS_HOST_CONTROLLER_PPI          *UfsHcPpi;
  UINT32                                 Index;
  UINTN                                  MmioBase;
  UINT8                                  Controller;
  UFS_UNIT_DESC                          UnitDescriptor;
  EDKII_UFS_HC_PLATFORM_PPI              *UfsHcPlatformPpi = NULL;
  UFS_DEV_DESC                           DeviceDescriptor;
  UINT8                                  RefClkAttr;
  EDKII_UFS_CARD_REF_CLK_FREQ_ATTRIBUTE  Attributes;
 
  //
  // Shadow this PEIM to run from memory
  //
  if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) {
    return EFI_SUCCESS;
  }
 
  //
  // locate ufs host controller PPI
  //
  Status = PeiServicesLocatePpi (
             &gEdkiiPeiUfsHostControllerPpiGuid,
             0,
             NULL,
             (VOID **)&UfsHcPpi
             );
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // Locate ufs host controller platform PPI
  //
  Status = PeiServicesLocatePpi (
             &gEdkiiUfsHcPlatformPpiGuid,
             0,
             NULL,
             (VOID **)&UfsHcPlatformPpi
             );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "LocatePpi gEdkiiUfsHcPlatformPpiGuid Status :%r\n", Status));
  }
 
  IoMmuInit ();
 
  Controller = 0;
  MmioBase   = 0;
  while (TRUE) {
    Status = UfsHcPpi->GetUfsHcMmioBar (UfsHcPpi, Controller, &MmioBase);
    //
    // When status is error, meant no controller is found
    //
    if (EFI_ERROR (Status)) {
      break;
    }
 
    Private = AllocateCopyPool (sizeof (UFS_PEIM_HC_PRIVATE_DATA), &gUfsHcPeimTemplate);
    if (Private == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      break;
    }
 
    Private->BlkIoPpiList.Ppi  = &Private->BlkIoPpi;
    Private->BlkIo2PpiList.Ppi = &Private->BlkIo2Ppi;
    Private->UfsHcBase         = MmioBase;
 
    //
    // Initialize the memory pool which will be used in all transactions.
    //
    Status = UfsPeimInitMemPool (Private);
    if (EFI_ERROR (Status)) {
      Status = EFI_OUT_OF_RESOURCES;
      break;
    }
 
    //
    // Initialize UFS Host Controller H/W.
    //
    Status = UfsControllerInit (UfsHcPlatformPpi, Private);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "UfsDevicePei: Host Controller Initialization Error, Status = %r\n", Status));
      Controller++;
      continue;
    }
 
    //
    // UFS 2.0 spec Section 13.1.3.3:
    // At the end of the UFS Interconnect Layer initialization on both host and device side,
    // the host shall send a NOP OUT UPIU to verify that the device UTP Layer is ready.
    //
    Status = UfsExecNopCmds (Private);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "Ufs Sending NOP IN command Error, Status = %r\n", Status));
      Controller++;
      continue;
    }
 
    //
    // Check the UFS device is initialized completed.
    //
    Status = UfsFinishDeviceInitialization (Private);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "Device failed to finish initialization, Status = %r\n", Status));
      Controller++;
      continue;
    }
 
    if ((UfsHcPlatformPpi != NULL) &&
        ((UfsHcPlatformPpi->RefClkFreq == EdkiiUfsCardRefClkFreq19p2Mhz) ||
         (UfsHcPlatformPpi->RefClkFreq == EdkiiUfsCardRefClkFreq26Mhz) ||
         (UfsHcPlatformPpi->RefClkFreq == EdkiiUfsCardRefClkFreq38p4Mhz)))
    {
      RefClkAttr = UfsAttrRefClkFreq;
      Attributes = EdkiiUfsCardRefClkFreqObsolete;
 
      Status = UfsRwAttributes (Private, TRUE, RefClkAttr, 0, 0, (UINT32 *)&Attributes);
      DEBUG ((DEBUG_INFO, "UfsRwAttributes #1 Status = %r \n", Status));
      if (!EFI_ERROR (Status)) {
        if (Attributes != UfsHcPlatformPpi->RefClkFreq) {
          Attributes = UfsHcPlatformPpi->RefClkFreq;
          DEBUG (
            (DEBUG_INFO,
             "Setting bRefClkFreq attribute(%x) to %x\n  0 -> 19.2 Mhz\n  1 -> 26 Mhz\n  2 -> 38.4 Mhz\n  3 -> Obsolete\n",
             RefClkAttr,
             Attributes)
            );
          Status = UfsRwAttributes (Private, FALSE, RefClkAttr, 0, 0, (UINT32 *)&Attributes);
          DEBUG ((DEBUG_INFO, "UfsRwAttributes #2 Status = %r \n", Status));
          if (EFI_ERROR (Status)) {
            DEBUG (
              (DEBUG_ERROR,
               "Failed to Change Reference Clock Attribute to, Status = %r \n",
               Status)
              );
          }
        }
      } else {
        DEBUG (
          (DEBUG_ERROR,
           "Failed to Read Reference Clock Attribute, Status = %r \n",
           Status)
          );
      }
    }
 
    if ((UfsHcPlatformPpi != NULL) && (UfsHcPlatformPpi->Callback != NULL)) {
      Status = UfsHcPlatformPpi->Callback (&Private->UfsHcBase, EdkiiUfsHcPostLinkStartup);
      if (EFI_ERROR (Status)) {
        DEBUG ((DEBUG_ERROR, "Failure from platform driver during EdkiiUfsHcPostLinkStartup, Status = %r\n", Status));
        Controller++;
        continue;
      }
 
      //
      // Check if 8 common luns are active and set corresponding bit mask.
      //
      for (Index = 0; Index < UFS_PEIM_MAX_LUNS; Index++) {
        Status = UfsRwDeviceDesc (Private, TRUE, UfsUnitDesc, (UINT8)Index, 0, &UnitDescriptor, sizeof (UFS_UNIT_DESC));
        if (EFI_ERROR (Status)) {
          DEBUG ((DEBUG_ERROR, "Fail to read UFS Unit Descriptor, Index = %X, Status = %r\n", Index, Status));
          continue;
        }
 
        if (UnitDescriptor.LunEn == 0x1) {
          DEBUG ((DEBUG_INFO, "Ufs %d Lun %d is enabled\n", Controller, Index));
          Private->Luns.BitMask |= (BIT0 << Index);
        }
      }
 
      //
      // Get Ufs Device's Lun Info by reading Configuration Descriptor
      //
      Status = UfsRwDeviceDesc (Private, TRUE, UfsConfigDesc, 0, 0, &DeviceDescriptor, sizeof (UFS_DEV_DESC));
      if (EFI_ERROR (Status)) {
        DEBUG ((DEBUG_ERROR, "Ufs Get Configuration Descriptor Error, Status = %r\n", Status));
        Controller++;
        continue;
      }
 
      if (DeviceDescriptor.SecurityLun == 0x1) {
        DEBUG ((DEBUG_INFO, "UFS WLUN RPMB is supported\n"));
        Private->Luns.BitMask |= BIT11;
      }
 
      PeiServicesInstallPpi (&Private->BlkIoPpiList);
      PeiServicesNotifyPpi (&Private->EndOfPeiNotifyList);
      Controller++;
    }
  }
 
  return EFI_SUCCESS;
}