SdBlockIoPei.c

Go to the documentation of this file.

 
#include "SdBlockIoPei.h"
 
//
// Template for SD HC Slot Data.
//
SD_PEIM_HC_SLOT  gSdHcSlotTemplate = {
  SD_PEIM_SLOT_SIG,               // Signature
  {                               // Media
    MSG_SD_DP,
    FALSE,
    TRUE,
    FALSE,
    0x200,
    0
  },
  0,                              // SdHcBase
  {                               // Capability
    0,
  },
  {                               // Csd
    0,
  },
  TRUE,                           // SectorAddressing
  NULL                            // Private
};
 
//
// Template for SD HC Private Data.
//
SD_PEIM_HC_PRIVATE_DATA  gSdHcPrivateTemplate = {
  SD_PEIM_SIG,                    // Signature
  NULL,                           // Pool
  {                               // BlkIoPpi
    SdBlockIoPeimGetDeviceNo,
    SdBlockIoPeimGetMediaInfo,
    SdBlockIoPeimReadBlocks
  },
  {                               // BlkIo2Ppi
    EFI_PEI_RECOVERY_BLOCK_IO2_PPI_REVISION,
    SdBlockIoPeimGetDeviceNo2,
    SdBlockIoPeimGetMediaInfo2,
    SdBlockIoPeimReadBlocks2
  },
  {                               // BlkIoPpiList
    EFI_PEI_PPI_DESCRIPTOR_PPI,
    &gEfiPeiVirtualBlockIoPpiGuid,
    NULL
  },
  {                               // BlkIo2PpiList
    EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
    &gEfiPeiVirtualBlockIo2PpiGuid,
    NULL
  },
  {
    (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
    &gEfiEndOfPeiSignalPpiGuid,
    SdBlockIoPeimEndOfPei
  },
  {                               // Slot
    {
      0,
    },
    {
      0,
    },
    {
      0,
    },
    {
      0,
    },
    {
      0,
    },
    {
      0,
    }
  },
  0,                              // SlotNum
  0                               // TotalBlkIoDevices
};
 
EFI_STATUS
EFIAPI
SdBlockIoPeimGetDeviceNo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  OUT UINTN                          *NumberBlockDevices
  )
{
  SD_PEIM_HC_PRIVATE_DATA  *Private;
 
  Private             = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS (This);
  *NumberBlockDevices = Private->TotalBlkIoDevices;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SdBlockIoPeimGetMediaInfo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  IN  UINTN                          DeviceIndex,
  OUT EFI_PEI_BLOCK_IO_MEDIA         *MediaInfo
  )
{
  SD_PEIM_HC_PRIVATE_DATA  *Private;
 
  Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS (This);
 
  if ((DeviceIndex == 0) || (DeviceIndex > Private->TotalBlkIoDevices) || (DeviceIndex > SD_PEIM_MAX_SLOTS)) {
    return EFI_INVALID_PARAMETER;
  }
 
  MediaInfo->DeviceType   = SD;
  MediaInfo->MediaPresent = TRUE;
  MediaInfo->LastBlock    = (UINTN)Private->Slot[DeviceIndex - 1].Media.LastBlock;
  MediaInfo->BlockSize    = Private->Slot[DeviceIndex - 1].Media.BlockSize;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SdBlockIoPeimReadBlocks (
  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;
  UINT32                   BlockSize;
  UINTN                    NumberOfBlocks;
  SD_PEIM_HC_PRIVATE_DATA  *Private;
  UINTN                    Remaining;
  UINT32                   MaxBlock;
 
  Status  = EFI_SUCCESS;
  Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS (This);
 
  //
  // Check parameters
  //
  if (Buffer == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (BufferSize == 0) {
    return EFI_SUCCESS;
  }
 
  if ((DeviceIndex == 0) || (DeviceIndex > Private->TotalBlkIoDevices) || (DeviceIndex > SD_PEIM_MAX_SLOTS)) {
    return EFI_INVALID_PARAMETER;
  }
 
  BlockSize = Private->Slot[DeviceIndex - 1].Media.BlockSize;
  if (BufferSize % BlockSize != 0) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (StartLBA > Private->Slot[DeviceIndex - 1].Media.LastBlock) {
    return EFI_INVALID_PARAMETER;
  }
 
  NumberOfBlocks = BufferSize / BlockSize;
 
  //
  // Start to execute data transfer. The max block number in single cmd is 65535 blocks.
  //
  Remaining = NumberOfBlocks;
  MaxBlock  = 0xFFFF;
 
  while (Remaining > 0) {
    if (Remaining <= MaxBlock) {
      NumberOfBlocks = Remaining;
    } else {
      NumberOfBlocks = MaxBlock;
    }
 
    BufferSize = NumberOfBlocks * BlockSize;
    if (NumberOfBlocks != 1) {
      Status = SdPeimRwMultiBlocks (&Private->Slot[DeviceIndex - 1], StartLBA, BlockSize, Buffer, BufferSize, TRUE);
    } else {
      Status = SdPeimRwSingleBlock (&Private->Slot[DeviceIndex - 1], StartLBA, BlockSize, Buffer, BufferSize, TRUE);
    }
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    StartLBA  += NumberOfBlocks;
    Buffer     = (UINT8 *)Buffer + BufferSize;
    Remaining -= NumberOfBlocks;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
SdBlockIoPeimGetDeviceNo2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  OUT UINTN                           *NumberBlockDevices
  )
{
  SD_PEIM_HC_PRIVATE_DATA  *Private;
 
  Private             = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS2 (This);
  *NumberBlockDevices = Private->TotalBlkIoDevices;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SdBlockIoPeimGetMediaInfo2 (
  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;
  SD_PEIM_HC_PRIVATE_DATA  *Private;
  EFI_PEI_BLOCK_IO_MEDIA   Media;
 
  Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS2 (This);
 
  Status = SdBlockIoPeimGetMediaInfo (
             PeiServices,
             &Private->BlkIoPpi,
             DeviceIndex,
             &Media
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  CopyMem (MediaInfo, &(Private->Slot[DeviceIndex - 1].Media), sizeof (EFI_PEI_BLOCK_IO2_MEDIA));
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SdBlockIoPeimReadBlocks2 (
  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;
  SD_PEIM_HC_PRIVATE_DATA  *Private;
 
  Status  = EFI_SUCCESS;
  Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS2 (This);
 
  Status = SdBlockIoPeimReadBlocks (
             PeiServices,
             &Private->BlkIoPpi,
             DeviceIndex,
             StartLBA,
             BufferSize,
             Buffer
             );
  return Status;
}
 
EFI_STATUS
EFIAPI
SdBlockIoPeimEndOfPei (
  IN EFI_PEI_SERVICES           **PeiServices,
  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
  IN VOID                       *Ppi
  )
{
  SD_PEIM_HC_PRIVATE_DATA  *Private;
 
  Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS_NOTIFY (NotifyDescriptor);
 
  if ((Private->Pool != NULL) && (Private->Pool->Head != NULL)) {
    SdPeimFreeMemPool (Private->Pool);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
InitializeSdBlockIoPeim (
  IN EFI_PEI_FILE_HANDLE     FileHandle,
  IN CONST EFI_PEI_SERVICES  **PeiServices
  )
{
  EFI_STATUS                        Status;
  SD_PEIM_HC_PRIVATE_DATA           *Private;
  EDKII_SD_MMC_HOST_CONTROLLER_PPI  *SdMmcHcPpi;
  UINT32                            Index;
  UINTN                             *MmioBase;
  UINT8                             BarNum;
  UINT8                             SlotNum;
  UINT8                             Controller;
  UINT64                            Capacity;
  SD_HC_SLOT_CAP                    Capability;
  SD_PEIM_HC_SLOT                   *Slot;
  SD_CSD                            *Csd;
  SD_CSD2                           *Csd2;
  UINT32                            CSize;
  UINT32                            CSizeMul;
  UINT32                            ReadBlLen;
 
  //
  // Shadow this PEIM to run from memory
  //
  if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) {
    return EFI_SUCCESS;
  }
 
  //
  // locate Sd host controller PPI
  //
  Status = PeiServicesLocatePpi (
             &gEdkiiPeiSdMmcHostControllerPpiGuid,
             0,
             NULL,
             (VOID **)&SdMmcHcPpi
             );
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  IoMmuInit ();
 
  Controller = 0;
  MmioBase   = NULL;
  while (TRUE) {
    Status = SdMmcHcPpi->GetSdMmcHcMmioBar (SdMmcHcPpi, Controller, &MmioBase, &BarNum);
    //
    // When status is error, meant no controller is found
    //
    if (EFI_ERROR (Status)) {
      break;
    }
 
    if (BarNum == 0) {
      Controller++;
      continue;
    }
 
    Private = AllocateCopyPool (sizeof (SD_PEIM_HC_PRIVATE_DATA), &gSdHcPrivateTemplate);
    if (Private == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      break;
    }
 
    Private->BlkIoPpiList.Ppi  = (VOID *)&Private->BlkIoPpi;
    Private->BlkIo2PpiList.Ppi = (VOID *)&Private->BlkIo2Ppi;
    //
    // Initialize the memory pool which will be used in all transactions.
    //
    Status = SdPeimInitMemPool (Private);
    if (EFI_ERROR (Status)) {
      Status = EFI_OUT_OF_RESOURCES;
      break;
    }
 
    for (Index = 0; Index < BarNum; Index++) {
      Status = SdPeimHcGetCapability (MmioBase[Index], &Capability);
      if (EFI_ERROR (Status)) {
        continue;
      }
 
      if (Capability.SlotType != 0x1) {
        DEBUG ((DEBUG_INFO, "The slot at 0x%x is not embedded slot type\n", MmioBase[Index]));
        Status = EFI_UNSUPPORTED;
        continue;
      }
 
      Status = SdPeimHcReset (MmioBase[Index]);
      if (EFI_ERROR (Status)) {
        continue;
      }
 
      Status = SdPeimHcCardDetect (MmioBase[Index]);
      if (EFI_ERROR (Status)) {
        continue;
      }
 
      Status = SdPeimHcInitHost (MmioBase[Index]);
      if (EFI_ERROR (Status)) {
        continue;
      }
 
      SlotNum = Private->SlotNum;
      Slot    = &Private->Slot[SlotNum];
      CopyMem (Slot, &gSdHcSlotTemplate, sizeof (SD_PEIM_HC_SLOT));
      Slot->Private  = Private;
      Slot->SdHcBase = MmioBase[Index];
      CopyMem (&Slot->Capability, &Capability, sizeof (Capability));
 
      Status = SdPeimIdentification (Slot);
      if (EFI_ERROR (Status)) {
        continue;
      }
 
      Csd = &Slot->Csd;
      if (Csd->CsdStructure == 0) {
        Slot->SectorAddressing = FALSE;
        CSize                  = (Csd->CSizeHigh << 2 | Csd->CSizeLow) + 1;
        CSizeMul               = (1 << (Csd->CSizeMul + 2));
        ReadBlLen              = (1 << (Csd->ReadBlLen));
        Capacity               = MultU64x32 (MultU64x32 ((UINT64)CSize, CSizeMul), ReadBlLen);
      } else {
        Slot->SectorAddressing = TRUE;
        Csd2                   = (SD_CSD2 *)(VOID *)Csd;
        CSize                  = (Csd2->CSizeHigh << 16 | Csd2->CSizeLow) + 1;
        Capacity               = MultU64x32 ((UINT64)CSize, SIZE_512KB);
      }
 
      Slot->Media.LastBlock = DivU64x32 (Capacity, Slot->Media.BlockSize) - 1;
 
      Private->TotalBlkIoDevices++;
      Private->SlotNum++;
    }
 
    Controller++;
    if (!EFI_ERROR (Status)) {
      PeiServicesInstallPpi (&Private->BlkIoPpiList);
      PeiServicesNotifyPpi (&Private->EndOfPeiNotifyList);
    } else {
      if (Private->Pool->Head != NULL) {
        SdPeimFreeMemPool (Private->Pool);
      }
    }
  }
 
  return EFI_SUCCESS;
}