AhciPeiBlockIo.c

Go to the documentation of this file.

 
#include "AhciPei.h"
 
PEI_AHCI_ATA_DEVICE_DATA *
SearchDeviceByIndex (
  IN PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private,
  IN UINTN                             DeviceIndex
  )
{
  PEI_AHCI_ATA_DEVICE_DATA  *DeviceData;
  LIST_ENTRY                *Node;
 
  if ((DeviceIndex == 0) || (DeviceIndex > Private->ActiveDevices)) {
    return NULL;
  }
 
  Node = GetFirstNode (&Private->DeviceList);
  while (!IsNull (&Private->DeviceList, Node)) {
    DeviceData = AHCI_PEI_ATA_DEVICE_INFO_FROM_THIS (Node);
 
    if (DeviceData->DeviceIndex == DeviceIndex) {
      return DeviceData;
    }
 
    Node = GetNextNode (&Private->DeviceList, Node);
  }
 
  return NULL;
}
 
EFI_STATUS
AccessAtaDevice (
  IN     PEI_AHCI_ATA_DEVICE_DATA  *DeviceData,
  IN OUT UINT8                     *Buffer,
  IN     EFI_LBA                   StartLba,
  IN     UINTN                     NumberOfBlocks
  )
{
  EFI_STATUS  Status;
  UINTN       MaxTransferBlockNumber;
  UINTN       TransferBlockNumber;
  UINTN       BlockSize;
 
  //
  // Ensure Lba48Bit is a valid boolean value
  //
  ASSERT ((UINTN)DeviceData->Lba48Bit < 2);
  if ((UINTN)DeviceData->Lba48Bit >= 2) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status                 = EFI_SUCCESS;
  MaxTransferBlockNumber = mMaxTransferBlockNumber[DeviceData->Lba48Bit];
  BlockSize              = DeviceData->Media.BlockSize;
 
  do {
    if (NumberOfBlocks > MaxTransferBlockNumber) {
      TransferBlockNumber = MaxTransferBlockNumber;
      NumberOfBlocks     -= MaxTransferBlockNumber;
    } else {
      TransferBlockNumber = NumberOfBlocks;
      NumberOfBlocks      = 0;
    }
 
    DEBUG ((
      DEBUG_BLKIO,
      "%a: Blocking AccessAtaDevice, TransferBlockNumber = %x; StartLba = %x\n",
      __func__,
      TransferBlockNumber,
      StartLba
      ));
 
    Status = TransferAtaDevice (
               DeviceData,
               Buffer,
               StartLba,
               (UINT32)TransferBlockNumber,
               FALSE  // Read
               );
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    StartLba += TransferBlockNumber;
    Buffer   += TransferBlockNumber * BlockSize;
  } while (NumberOfBlocks > 0);
 
  return Status;
}
 
EFI_STATUS
AhciRead (
  IN  PEI_AHCI_ATA_DEVICE_DATA  *DeviceData,
  OUT VOID                      *Buffer,
  IN  EFI_LBA                   StartLba,
  IN  UINTN                     BufferSize
  )
{
  EFI_STATUS  Status;
  UINTN       BlockSize;
  UINTN       NumberOfBlocks;
 
  //
  // Check parameters.
  //
  if (Buffer == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (BufferSize == 0) {
    return EFI_SUCCESS;
  }
 
  BlockSize = DeviceData->Media.BlockSize;
  if ((BufferSize % BlockSize) != 0) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (StartLba > DeviceData->Media.LastBlock) {
    return EFI_INVALID_PARAMETER;
  }
 
  NumberOfBlocks = BufferSize / BlockSize;
  if (NumberOfBlocks - 1 > DeviceData->Media.LastBlock - StartLba) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Invoke low level AtaDevice Access Routine.
  //
  Status = AccessAtaDevice (DeviceData, Buffer, StartLba, NumberOfBlocks);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
AhciBlockIoGetDeviceNo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  OUT UINTN                          *NumberBlockDevices
  )
{
  PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
 
  if ((This == NULL) || (NumberBlockDevices == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private             = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO (This);
  *NumberBlockDevices = Private->ActiveDevices;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AhciBlockIoGetMediaInfo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  IN  UINTN                          DeviceIndex,
  OUT EFI_PEI_BLOCK_IO_MEDIA         *MediaInfo
  )
{
  PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
  PEI_AHCI_ATA_DEVICE_DATA          *DeviceData;
 
  if ((This == NULL) || (MediaInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private    = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO (This);
  DeviceData = SearchDeviceByIndex (Private, DeviceIndex);
  if (DeviceData == NULL) {
    return EFI_NOT_FOUND;
  }
 
  MediaInfo->DeviceType   = (EFI_PEI_BLOCK_DEVICE_TYPE)EDKII_PEI_BLOCK_DEVICE_TYPE_ATA_HARD_DISK;
  MediaInfo->MediaPresent = TRUE;
  MediaInfo->LastBlock    = (UINTN)DeviceData->Media.LastBlock;
  MediaInfo->BlockSize    = DeviceData->Media.BlockSize;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AhciBlockIoReadBlocks (
  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_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
  PEI_AHCI_ATA_DEVICE_DATA          *DeviceData;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private    = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO (This);
  DeviceData = SearchDeviceByIndex (Private, DeviceIndex);
  if (DeviceData == NULL) {
    return EFI_NOT_FOUND;
  }
 
  return AhciRead (DeviceData, Buffer, StartLBA, BufferSize);
}
 
EFI_STATUS
EFIAPI
AhciBlockIoGetDeviceNo2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  OUT UINTN                           *NumberBlockDevices
  )
{
  PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
 
  if ((This == NULL) || (NumberBlockDevices == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private             = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO2 (This);
  *NumberBlockDevices = Private->ActiveDevices;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AhciBlockIoGetMediaInfo2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  IN  UINTN                           DeviceIndex,
  OUT EFI_PEI_BLOCK_IO2_MEDIA         *MediaInfo
  )
{
  PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
  PEI_AHCI_ATA_DEVICE_DATA          *DeviceData;
 
  if ((This == NULL) || (MediaInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private    = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO2 (This);
  DeviceData = SearchDeviceByIndex (Private, DeviceIndex);
  if (DeviceData == NULL) {
    return EFI_NOT_FOUND;
  }
 
  CopyMem (
    MediaInfo,
    &DeviceData->Media,
    sizeof (EFI_PEI_BLOCK_IO2_MEDIA)
    );
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AhciBlockIoReadBlocks2 (
  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_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_BLKIO2 (This);
  return AhciBlockIoReadBlocks (
           PeiServices,
           &Private->BlkIoPpi,
           DeviceIndex,
           StartLBA,
           BufferSize,
           Buffer
           );
}