FatLiteApi.c

Go to the documentation of this file.

 
#include "FatLitePeim.h"
 
PEI_FAT_PRIVATE_DATA  *mPrivateData = NULL;
 
EFI_STATUS
EFIAPI
BlockIoNotifyEntry (
  IN EFI_PEI_SERVICES           **PeiServices,
  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
  IN VOID                       *Ppi
  );
 
EFI_STATUS
UpdateBlocksAndVolumes (
  IN OUT PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN     BOOLEAN               BlockIo2
  )
{
  EFI_STATUS                      Status;
  EFI_PEI_PPI_DESCRIPTOR          *TempPpiDescriptor;
  UINTN                           BlockIoPpiInstance;
  EFI_PEI_RECOVERY_BLOCK_IO_PPI   *BlockIoPpi;
  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *BlockIo2Ppi;
  UINTN                           NumberBlockDevices;
  UINTN                           Index;
  EFI_PEI_BLOCK_IO_MEDIA          Media;
  EFI_PEI_BLOCK_IO2_MEDIA         Media2;
  PEI_FAT_VOLUME                  Volume;
  EFI_PEI_SERVICES                **PeiServices;
 
  PeiServices = (EFI_PEI_SERVICES **)GetPeiServicesTablePointer ();
  BlockIo2Ppi = NULL;
  BlockIoPpi  = NULL;
  //
  // Clean up caches
  //
  for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
    PrivateData->CacheBuffer[Index].Valid = FALSE;
  }
 
  PrivateData->BlockDeviceCount = 0;
 
  //
  // Find out all Block Io Ppi instances within the system
  // Assuming all device Block Io Peims are dispatched already
  //
  for (BlockIoPpiInstance = 0; BlockIoPpiInstance < PEI_FAT_MAX_BLOCK_IO_PPI; BlockIoPpiInstance++) {
    if (BlockIo2) {
      Status = PeiServicesLocatePpi (
                 &gEfiPeiVirtualBlockIo2PpiGuid,
                 BlockIoPpiInstance,
                 &TempPpiDescriptor,
                 (VOID **)&BlockIo2Ppi
                 );
    } else {
      Status = PeiServicesLocatePpi (
                 &gEfiPeiVirtualBlockIoPpiGuid,
                 BlockIoPpiInstance,
                 &TempPpiDescriptor,
                 (VOID **)&BlockIoPpi
                 );
    }
 
    if (EFI_ERROR (Status)) {
      //
      // Done with all Block Io Ppis
      //
      break;
    }
 
    if (BlockIo2) {
      Status = BlockIo2Ppi->GetNumberOfBlockDevices (
                              PeiServices,
                              BlockIo2Ppi,
                              &NumberBlockDevices
                              );
    } else {
      Status = BlockIoPpi->GetNumberOfBlockDevices (
                             PeiServices,
                             BlockIoPpi,
                             &NumberBlockDevices
                             );
    }
 
    if (EFI_ERROR (Status)) {
      continue;
    }
 
    for (Index = 1; Index <= NumberBlockDevices && PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE; Index++) {
      if (BlockIo2) {
        Status = BlockIo2Ppi->GetBlockDeviceMediaInfo (
                                PeiServices,
                                BlockIo2Ppi,
                                Index,
                                &Media2
                                );
        if (EFI_ERROR (Status) || !Media2.MediaPresent) {
          continue;
        }
 
        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo2      = BlockIo2Ppi;
        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].InterfaceType = Media2.InterfaceType;
        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock     = Media2.LastBlock;
        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize     = Media2.BlockSize;
      } else {
        Status = BlockIoPpi->GetBlockDeviceMediaInfo (
                               PeiServices,
                               BlockIoPpi,
                               Index,
                               &Media
                               );
        if (EFI_ERROR (Status) || !Media.MediaPresent) {
          continue;
        }
 
        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo   = BlockIoPpi;
        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].DevType   = Media.DeviceType;
        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock = Media.LastBlock;
        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize = (UINT32)Media.BlockSize;
      }
 
      PrivateData->BlockDevice[PrivateData->BlockDeviceCount].IoAlign = 0;
      //
      // Not used here
      //
      PrivateData->BlockDevice[PrivateData->BlockDeviceCount].Logical          = FALSE;
      PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PartitionChecked = FALSE;
 
      PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PhysicalDevNo = (UINT8)Index;
      PrivateData->BlockDeviceCount++;
    }
  }
 
  //
  // Find out all logical devices
  //
  FatFindPartitions (PrivateData);
 
  //
  // Build up file system volume array
  //
  PrivateData->VolumeCount = 0;
  for (Index = 0; Index < PrivateData->BlockDeviceCount; Index++) {
    Volume.BlockDeviceNo = Index;
    Status               = FatGetBpbInfo (PrivateData, &Volume);
    if (Status == EFI_SUCCESS) {
      //
      // Add the detected volume to the volume array
      //
      CopyMem (
        (UINT8 *)&(PrivateData->Volume[PrivateData->VolumeCount]),
        (UINT8 *)&Volume,
        sizeof (PEI_FAT_VOLUME)
        );
      PrivateData->VolumeCount += 1;
      if (PrivateData->VolumeCount >= PEI_FAT_MAX_VOLUME) {
        break;
      }
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BlockIoNotifyEntry (
  IN EFI_PEI_SERVICES           **PeiServices,
  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
  IN VOID                       *Ppi
  )
{
  if (CompareGuid (NotifyDescriptor->Guid, &gEfiPeiVirtualBlockIo2PpiGuid)) {
    UpdateBlocksAndVolumes (mPrivateData, TRUE);
  } else {
    UpdateBlocksAndVolumes (mPrivateData, FALSE);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FatPeimEntry (
  IN EFI_PEI_FILE_HANDLE     FileHandle,
  IN CONST EFI_PEI_SERVICES  **PeiServices
  )
{
  EFI_STATUS            Status;
  EFI_PHYSICAL_ADDRESS  Address;
  PEI_FAT_PRIVATE_DATA  *PrivateData;
 
  Status = PeiServicesRegisterForShadow (FileHandle);
  if (!EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = PeiServicesAllocatePages (
             EfiBootServicesCode,
             (sizeof (PEI_FAT_PRIVATE_DATA) - 1) / PEI_FAT_MEMORY_PAGE_SIZE + 1,
             &Address
             );
  if (EFI_ERROR (Status)) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  PrivateData = (PEI_FAT_PRIVATE_DATA *)(UINTN)Address;
 
  //
  // Initialize Private Data (to zero, as is required by subsequent operations)
  //
  ZeroMem ((UINT8 *)PrivateData, sizeof (PEI_FAT_PRIVATE_DATA));
 
  PrivateData->Signature = PEI_FAT_PRIVATE_DATA_SIGNATURE;
 
  //
  // Installs Ppi
  //
  PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules;
  PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo    = GetRecoveryCapsuleInfo;
  PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule       = LoadRecoveryCapsule;
 
  PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);
  PrivateData->PpiDescriptor.Guid  = &gEfiPeiDeviceRecoveryModulePpiGuid;
  PrivateData->PpiDescriptor.Ppi   = &PrivateData->DeviceRecoveryPpi;
 
  Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor);
  if (EFI_ERROR (Status)) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Other initializations
  //
  PrivateData->BlockDeviceCount = 0;
 
  UpdateBlocksAndVolumes (PrivateData, TRUE);
  UpdateBlocksAndVolumes (PrivateData, FALSE);
 
  //
  // PrivateData is allocated now, set it to the module variable
  //
  mPrivateData = PrivateData;
 
  //
  // Installs Block Io Ppi notification function
  //
  PrivateData->NotifyDescriptor[0].Flags =
    (
     EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK
    );
  PrivateData->NotifyDescriptor[0].Guid   = &gEfiPeiVirtualBlockIoPpiGuid;
  PrivateData->NotifyDescriptor[0].Notify = BlockIoNotifyEntry;
  PrivateData->NotifyDescriptor[1].Flags  =
    (
     EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK |
     EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
    );
  PrivateData->NotifyDescriptor[1].Guid   = &gEfiPeiVirtualBlockIo2PpiGuid;
  PrivateData->NotifyDescriptor[1].Notify = BlockIoNotifyEntry;
  return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor[0]);
}
 
EFI_STATUS
EFIAPI
GetNumberRecoveryCapsules (
  IN EFI_PEI_SERVICES                    **PeiServices,
  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  *This,
  OUT UINTN                              *NumberRecoveryCapsules
  )
{
  EFI_STATUS            Status;
  PEI_FAT_PRIVATE_DATA  *PrivateData;
  UINTN                 Index;
  UINTN                 RecoveryCapsuleCount;
  PEI_FILE_HANDLE       Handle;
 
  PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
 
  //
  // Search each volume in the root directory for the Recovery capsule
  //
  RecoveryCapsuleCount = 0;
  for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
    Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);
    if (EFI_ERROR (Status)) {
      continue;
    }
 
    RecoveryCapsuleCount++;
  }
 
  *NumberRecoveryCapsules = RecoveryCapsuleCount;
 
  if (*NumberRecoveryCapsules == 0) {
    return EFI_NOT_FOUND;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
GetRecoveryCapsuleInfo (
  IN  EFI_PEI_SERVICES                    **PeiServices,
  IN  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  *This,
  IN  UINTN                               CapsuleInstance,
  OUT UINTN                               *Size,
  OUT EFI_GUID                            *CapsuleType
  )
{
  EFI_STATUS            Status;
  PEI_FAT_PRIVATE_DATA  *PrivateData;
  UINTN                 Index;
  UINTN                 BlockDeviceNo;
  UINTN                 RecoveryCapsuleCount;
  PEI_FILE_HANDLE       Handle;
  UINTN                 NumberRecoveryCapsules;
 
  Handle = NULL;
 
  Status = GetNumberRecoveryCapsules (PeiServices, This, &NumberRecoveryCapsules);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if ((CapsuleInstance == 0) || (CapsuleInstance > NumberRecoveryCapsules)) {
    return EFI_NOT_FOUND;
  }
 
  PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
 
  //
  // Search each volume in the root directory for the Recovery capsule
  //
  RecoveryCapsuleCount = 0;
  for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
    Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);
 
    if (EFI_ERROR (Status)) {
      continue;
    }
 
    if (CapsuleInstance - 1 == RecoveryCapsuleCount) {
      //
      // Get file size
      //
      *Size = (UINTN)(((PEI_FAT_FILE *)Handle)->FileSize);
 
      //
      // Find corresponding physical block device
      //
      BlockDeviceNo = PrivateData->Volume[Index].BlockDeviceNo;
      while (BlockDeviceNo < PrivateData->BlockDeviceCount && PrivateData->BlockDevice[BlockDeviceNo].Logical) {
        BlockDeviceNo = PrivateData->BlockDevice[BlockDeviceNo].ParentDevNo;
      }
 
      //
      // Fill in the Capsule Type GUID according to the block device type
      //
      if (BlockDeviceNo < PrivateData->BlockDeviceCount) {
        if (PrivateData->BlockDevice[BlockDeviceNo].BlockIo2 != NULL) {
          switch (PrivateData->BlockDevice[BlockDeviceNo].InterfaceType) {
            case MSG_ATAPI_DP:
              CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);
              break;
 
            case MSG_USB_DP:
              CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);
              break;
 
            case MSG_NVME_NAMESPACE_DP:
              CopyGuid (CapsuleType, &gRecoveryOnFatNvmeDiskGuid);
              break;
 
            default:
              break;
          }
        }
 
        if (PrivateData->BlockDevice[BlockDeviceNo].BlockIo != NULL) {
          switch (PrivateData->BlockDevice[BlockDeviceNo].DevType) {
            case LegacyFloppy:
              CopyGuid (CapsuleType, &gRecoveryOnFatFloppyDiskGuid);
              break;
 
            case IdeCDROM:
            case IdeLS120:
              CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);
              break;
 
            case UsbMassStorage:
              CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);
              break;
 
            default:
              break;
          }
        }
      }
 
      return EFI_SUCCESS;
    }
 
    RecoveryCapsuleCount++;
  }
 
  return EFI_NOT_FOUND;
}
 
EFI_STATUS
EFIAPI
LoadRecoveryCapsule (
  IN EFI_PEI_SERVICES                    **PeiServices,
  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  *This,
  IN UINTN                               CapsuleInstance,
  OUT VOID                               *Buffer
  )
{
  EFI_STATUS            Status;
  PEI_FAT_PRIVATE_DATA  *PrivateData;
  UINTN                 Index;
  UINTN                 RecoveryCapsuleCount;
  PEI_FILE_HANDLE       Handle;
  UINTN                 NumberRecoveryCapsules;
 
  Handle = NULL;
 
  Status = GetNumberRecoveryCapsules (PeiServices, This, &NumberRecoveryCapsules);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if ((CapsuleInstance == 0) || (CapsuleInstance > NumberRecoveryCapsules)) {
    return EFI_NOT_FOUND;
  }
 
  PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
 
  //
  // Search each volume in the root directory for the Recovery capsule
  //
  RecoveryCapsuleCount = 0;
  for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
    Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);
    if (EFI_ERROR (Status)) {
      continue;
    }
 
    if (CapsuleInstance - 1 == RecoveryCapsuleCount) {
      Status = FatReadFile (
                 PrivateData,
                 Handle,
                 (UINTN)(((PEI_FAT_FILE *)Handle)->FileSize),
                 Buffer
                 );
      return Status;
    }
 
    RecoveryCapsuleCount++;
  }
 
  return EFI_NOT_FOUND;
}
 
EFI_STATUS
FindRecoveryFile (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  UINTN                 VolumeIndex,
  IN  CHAR16                *FileName,
  OUT PEI_FILE_HANDLE       *Handle
  )
{
  EFI_STATUS    Status;
  PEI_FAT_FILE  Parent;
  PEI_FAT_FILE  *File;
 
  File = &PrivateData->File;
 
  //
  // VolumeIndex must be less than PEI_FAT_MAX_VOLUME because PrivateData->VolumeCount
  // cannot be larger than PEI_FAT_MAX_VOLUME when detecting recovery volume.
  //
  ASSERT (VolumeIndex < PEI_FAT_MAX_VOLUME);
 
  //
  // Construct root directory file
  //
  ZeroMem (&Parent, sizeof (PEI_FAT_FILE));
  Parent.IsFixedRootDir  = (BOOLEAN)((PrivateData->Volume[VolumeIndex].FatType == Fat32) ? FALSE : TRUE);
  Parent.Attributes      = FAT_ATTR_DIRECTORY;
  Parent.CurrentPos      = 0;
  Parent.CurrentCluster  = Parent.IsFixedRootDir ? 0 : PrivateData->Volume[VolumeIndex].RootDirCluster;
  Parent.StartingCluster = Parent.CurrentCluster;
  Parent.Volume          = &PrivateData->Volume[VolumeIndex];
 
  Status = FatSetFilePos (PrivateData, &Parent, 0);
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // Search for recovery capsule in root directory
  //
  Status = FatReadNextDirectoryEntry (PrivateData, &Parent, File);
  while (Status == EFI_SUCCESS) {
    //
    // Compare whether the file name is recovery file name.
    //
    if (EngStriColl (PrivateData, FileName, File->FileName)) {
      break;
    }
 
    Status = FatReadNextDirectoryEntry (PrivateData, &Parent, File);
  }
 
  if (EFI_ERROR (Status)) {
    return EFI_NOT_FOUND;
  }
 
  //
  // Get the recovery file, set its file position to 0.
  //
  if (File->StartingCluster != 0) {
    Status = FatSetFilePos (PrivateData, File, 0);
  }
 
  *Handle = File;
 
  return EFI_SUCCESS;
}