NvmExpressPeiBlockIo.c

Go to the documentation of this file.

 
#include "NvmExpressPei.h"
 
EFI_STATUS
ReadSectors (
  IN  PEI_NVME_NAMESPACE_INFO  *NamespaceInfo,
  OUT UINTN                    Buffer,
  IN  UINT64                   Lba,
  IN  UINT32                   Blocks
  )
{
  EFI_STATUS                                Status;
  UINT32                                    BlockSize;
  PEI_NVME_CONTROLLER_PRIVATE_DATA          *Private;
  UINT32                                    Bytes;
  EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET  CommandPacket;
  EFI_NVM_EXPRESS_COMMAND                   Command;
  EFI_NVM_EXPRESS_COMPLETION                Completion;
  EDKII_PEI_NVM_EXPRESS_PASS_THRU_PPI       *NvmePassThru;
 
  Private      = NamespaceInfo->Controller;
  NvmePassThru = &Private->NvmePassThruPpi;
  BlockSize    = NamespaceInfo->Media.BlockSize;
  Bytes        = Blocks * BlockSize;
 
  ZeroMem (&CommandPacket, sizeof (EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET));
  ZeroMem (&Command, sizeof (EFI_NVM_EXPRESS_COMMAND));
  ZeroMem (&Completion, sizeof (EFI_NVM_EXPRESS_COMPLETION));
 
  CommandPacket.NvmeCmd        = &Command;
  CommandPacket.NvmeCompletion = &Completion;
 
  CommandPacket.NvmeCmd->Cdw0.Opcode = NVME_IO_READ_OPC;
  CommandPacket.NvmeCmd->Nsid        = NamespaceInfo->NamespaceId;
  CommandPacket.TransferBuffer       = (VOID *)Buffer;
 
  CommandPacket.TransferLength = Bytes;
  CommandPacket.CommandTimeout = NVME_GENERIC_TIMEOUT;
  CommandPacket.QueueType      = NVME_IO_QUEUE;
 
  CommandPacket.NvmeCmd->Cdw10 = (UINT32)Lba;
  CommandPacket.NvmeCmd->Cdw11 = (UINT32)RShiftU64 (Lba, 32);
  CommandPacket.NvmeCmd->Cdw12 = (Blocks - 1) & 0xFFFF;
 
  CommandPacket.NvmeCmd->Flags = CDW10_VALID | CDW11_VALID | CDW12_VALID;
 
  Status = NvmePassThru->PassThru (
                           NvmePassThru,
                           NamespaceInfo->NamespaceId,
                           &CommandPacket
                           );
 
  return Status;
}
 
EFI_STATUS
NvmeRead (
  IN  PEI_NVME_NAMESPACE_INFO  *NamespaceInfo,
  OUT UINTN                    Buffer,
  IN  UINT64                   Lba,
  IN  UINTN                    Blocks
  )
{
  EFI_STATUS                        Status;
  UINT32                            Retries;
  UINT32                            BlockSize;
  PEI_NVME_CONTROLLER_PRIVATE_DATA  *Private;
  UINT32                            MaxTransferBlocks;
  UINTN                             OrginalBlocks;
 
  Status        = EFI_SUCCESS;
  Retries       = 0;
  Private       = NamespaceInfo->Controller;
  BlockSize     = NamespaceInfo->Media.BlockSize;
  OrginalBlocks = Blocks;
 
  if (Private->ControllerData->Mdts != 0) {
    MaxTransferBlocks = (1 << (Private->ControllerData->Mdts)) * (1 << (Private->Cap.Mpsmin + 12)) / BlockSize;
  } else {
    MaxTransferBlocks = 1024;
  }
 
  while (Blocks > 0) {
    Status = ReadSectors (
               NamespaceInfo,
               Buffer,
               Lba,
               Blocks > MaxTransferBlocks ? MaxTransferBlocks : (UINT32)Blocks
               );
    if (EFI_ERROR (Status)) {
      Retries++;
      MaxTransferBlocks = MaxTransferBlocks >> 1;
 
      if ((Retries > NVME_READ_MAX_RETRY) || (MaxTransferBlocks < 1)) {
        DEBUG ((DEBUG_ERROR, "%a: ReadSectors fail, Status - %r\n", __func__, Status));
        break;
      }
 
      DEBUG ((
        DEBUG_BLKIO,
        "%a: ReadSectors fail, retry with smaller transfer block number - 0x%x\n",
        __func__,
        MaxTransferBlocks
        ));
      continue;
    }
 
    if (Blocks > MaxTransferBlocks) {
      Blocks -= MaxTransferBlocks;
      Buffer += (MaxTransferBlocks * BlockSize);
      Lba    += MaxTransferBlocks;
    } else {
      Blocks = 0;
    }
  }
 
  DEBUG ((
    DEBUG_BLKIO,
    "%a: Lba = 0x%08Lx, Original = 0x%08Lx, "
    "Remaining = 0x%08Lx, BlockSize = 0x%x, Status = %r\n",
    __func__,
    Lba,
    (UINT64)OrginalBlocks,
    (UINT64)Blocks,
    BlockSize,
    Status
    ));
  return Status;
}
 
EFI_STATUS
EFIAPI
NvmeBlockIoPeimGetDeviceNo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  OUT UINTN                          *NumberBlockDevices
  )
{
  PEI_NVME_CONTROLLER_PRIVATE_DATA  *Private;
 
  if ((This == NULL) || (NumberBlockDevices == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private             = GET_NVME_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO (This);
  *NumberBlockDevices = Private->ActiveNamespaceNum;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NvmeBlockIoPeimGetMediaInfo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  IN  UINTN                          DeviceIndex,
  OUT EFI_PEI_BLOCK_IO_MEDIA         *MediaInfo
  )
{
  PEI_NVME_CONTROLLER_PRIVATE_DATA  *Private;
 
  if ((This == NULL) || (MediaInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GET_NVME_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO (This);
 
  if ((DeviceIndex == 0) || (DeviceIndex > Private->ActiveNamespaceNum)) {
    return EFI_INVALID_PARAMETER;
  }
 
  MediaInfo->DeviceType   = (EFI_PEI_BLOCK_DEVICE_TYPE)EDKII_PEI_BLOCK_DEVICE_TYPE_NVME;
  MediaInfo->MediaPresent = TRUE;
  MediaInfo->LastBlock    = (UINTN)Private->NamespaceInfo[DeviceIndex-1].Media.LastBlock;
  MediaInfo->BlockSize    = Private->NamespaceInfo[DeviceIndex-1].Media.BlockSize;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NvmeBlockIoPeimReadBlocks (
  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
  )
{
  PEI_NVME_CONTROLLER_PRIVATE_DATA  *Private;
  PEI_NVME_NAMESPACE_INFO           *NamespaceInfo;
  UINT32                            BlockSize;
  UINTN                             NumberOfBlocks;
 
  Private = GET_NVME_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO (This);
 
  //
  // Check parameters
  //
  if ((This == NULL) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (BufferSize == 0) {
    return EFI_SUCCESS;
  }
 
  if ((DeviceIndex == 0) || (DeviceIndex > Private->ActiveNamespaceNum)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Check BufferSize and StartLBA
  //
  NamespaceInfo = &(Private->NamespaceInfo[DeviceIndex - 1]);
  BlockSize     = NamespaceInfo->Media.BlockSize;
  if (BufferSize % BlockSize != 0) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (StartLBA > NamespaceInfo->Media.LastBlock) {
    return EFI_INVALID_PARAMETER;
  }
 
  NumberOfBlocks = BufferSize / BlockSize;
  if (NumberOfBlocks - 1 > NamespaceInfo->Media.LastBlock - StartLBA) {
    return EFI_INVALID_PARAMETER;
  }
 
  return NvmeRead (NamespaceInfo, (UINTN)Buffer, StartLBA, NumberOfBlocks);
}
 
EFI_STATUS
EFIAPI
NvmeBlockIoPeimGetDeviceNo2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  OUT UINTN                           *NumberBlockDevices
  )
{
  PEI_NVME_CONTROLLER_PRIVATE_DATA  *Private;
 
  if ((This == NULL) || (NumberBlockDevices == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private             = GET_NVME_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO2 (This);
  *NumberBlockDevices = Private->ActiveNamespaceNum;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NvmeBlockIoPeimGetMediaInfo2 (
  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;
  PEI_NVME_CONTROLLER_PRIVATE_DATA  *Private;
  EFI_PEI_BLOCK_IO_MEDIA            Media;
 
  if ((This == NULL) || (MediaInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GET_NVME_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO2 (This);
 
  Status = NvmeBlockIoPeimGetMediaInfo (
             PeiServices,
             &Private->BlkIoPpi,
             DeviceIndex,
             &Media
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  CopyMem (
    MediaInfo,
    &(Private->NamespaceInfo[DeviceIndex - 1].Media),
    sizeof (EFI_PEI_BLOCK_IO2_MEDIA)
    );
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NvmeBlockIoPeimReadBlocks2 (
  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
  )
{
  PEI_NVME_CONTROLLER_PRIVATE_DATA  *Private;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GET_NVME_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO2 (This);
  return NvmeBlockIoPeimReadBlocks (
           PeiServices,
           &Private->BlkIoPpi,
           DeviceIndex,
           StartLBA,
           BufferSize,
           Buffer
           );
}