FatLiteLib.c

Go to the documentation of this file.

 
#include "FatLitePeim.h"
 
#define CHAR_FAT_VALID  0x01
 
CHAR16
ToUpper (
  IN CHAR16  Letter
  )
{
  if (('a' <= Letter) && (Letter <= 'z')) {
    Letter = (CHAR16)(Letter - 0x20);
  }
 
  return Letter;
}
 
EFI_STATUS
FatReadBlock (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  UINTN                 BlockDeviceNo,
  IN  EFI_PEI_LBA           Lba,
  IN  UINTN                 BufferSize,
  OUT VOID                  *Buffer
  )
{
  EFI_STATUS            Status;
  PEI_FAT_BLOCK_DEVICE  *BlockDev;
 
  if (BlockDeviceNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
    return EFI_DEVICE_ERROR;
  }
 
  Status   = EFI_SUCCESS;
  BlockDev = &(PrivateData->BlockDevice[BlockDeviceNo]);
 
  if (BufferSize > MultU64x32 (BlockDev->LastBlock - Lba + 1, BlockDev->BlockSize)) {
    return EFI_DEVICE_ERROR;
  }
 
  if (!BlockDev->Logical) {
    //
    // Status = BlockDev->ReadFunc
    //  (PrivateData->PeiServices, BlockDev->PhysicalDevNo, Lba, BufferSize, Buffer);
    //
    if (BlockDev->BlockIo2 != NULL) {
      Status = BlockDev->BlockIo2->ReadBlocks (
                                     (EFI_PEI_SERVICES **)GetPeiServicesTablePointer (),
                                     BlockDev->BlockIo2,
                                     BlockDev->PhysicalDevNo,
                                     Lba,
                                     BufferSize,
                                     Buffer
                                     );
    } else {
      Status = BlockDev->BlockIo->ReadBlocks (
                                    (EFI_PEI_SERVICES **)GetPeiServicesTablePointer (),
                                    BlockDev->BlockIo,
                                    BlockDev->PhysicalDevNo,
                                    Lba,
                                    BufferSize,
                                    Buffer
                                    );
    }
  } else {
    Status = FatReadDisk (
               PrivateData,
               BlockDev->ParentDevNo,
               BlockDev->StartingPos + MultU64x32 (Lba, BlockDev->BlockSize),
               BufferSize,
               Buffer
               );
  }
 
  return Status;
}
 
EFI_STATUS
FatGetCacheBlock (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  UINTN                 BlockDeviceNo,
  IN  UINT64                Lba,
  OUT CHAR8                 **CachePtr
  )
{
  EFI_STATUS            Status;
  PEI_FAT_CACHE_BUFFER  *CacheBuffer;
  INTN                  Index;
  STATIC UINT8          Seed;
 
  Status      = EFI_SUCCESS;
  CacheBuffer = NULL;
 
  //
  // go through existing cache buffers
  //
  for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
    CacheBuffer = &(PrivateData->CacheBuffer[Index]);
    if (CacheBuffer->Valid && (CacheBuffer->BlockDeviceNo == BlockDeviceNo) && (CacheBuffer->Lba == Lba)) {
      break;
    }
  }
 
  if (Index < PEI_FAT_CACHE_SIZE) {
    *CachePtr = (CHAR8 *)CacheBuffer->Buffer;
    return EFI_SUCCESS;
  }
 
  //
  // We have to find an invalid cache buffer
  //
  for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
    if (!PrivateData->CacheBuffer[Index].Valid) {
      break;
    }
  }
 
  //
  // Use the cache buffer
  //
  if (Index == PEI_FAT_CACHE_SIZE) {
    Index = (Seed++) % PEI_FAT_CACHE_SIZE;
  }
 
  //
  // Current device ID should be less than maximum device ID.
  //
  if (BlockDeviceNo >= PEI_FAT_MAX_BLOCK_DEVICE) {
    return EFI_DEVICE_ERROR;
  }
 
  CacheBuffer = &(PrivateData->CacheBuffer[Index]);
 
  CacheBuffer->BlockDeviceNo = BlockDeviceNo;
  CacheBuffer->Lba           = Lba;
  CacheBuffer->Size          = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;
 
  //
  // Read in the data
  //
  Status = FatReadBlock (
             PrivateData,
             BlockDeviceNo,
             Lba,
             CacheBuffer->Size,
             CacheBuffer->Buffer
             );
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  CacheBuffer->Valid = TRUE;
  *CachePtr          = (CHAR8 *)CacheBuffer->Buffer;
 
  return Status;
}
 
EFI_STATUS
FatReadDisk (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  UINTN                 BlockDeviceNo,
  IN  UINT64                StartingAddress,
  IN  UINTN                 Size,
  OUT VOID                  *Buffer
  )
{
  EFI_STATUS  Status;
  UINT32      BlockSize;
  CHAR8       *BufferPtr;
  CHAR8       *CachePtr;
  UINT32      Offset;
  UINT64      Lba;
  UINT64      OverRunLba;
  UINTN       Amount;
 
  Status    = EFI_SUCCESS;
  BufferPtr = Buffer;
  BlockSize = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;
 
  //
  // Read underrun
  //
  Lba    = DivU64x32Remainder (StartingAddress, BlockSize, &Offset);
  Status = FatGetCacheBlock (PrivateData, BlockDeviceNo, Lba, &CachePtr);
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  Amount = Size < (BlockSize - Offset) ? Size : (BlockSize - Offset);
  CopyMem (BufferPtr, CachePtr + Offset, Amount);
 
  if (Size == Amount) {
    return EFI_SUCCESS;
  }
 
  Size            -= Amount;
  BufferPtr       += Amount;
  StartingAddress += Amount;
  Lba             += 1;
 
  //
  // Read aligned parts
  //
  OverRunLba = Lba + DivU64x32Remainder (Size, BlockSize, &Offset);
 
  Size  -= Offset;
  Status = FatReadBlock (PrivateData, BlockDeviceNo, Lba, Size, BufferPtr);
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  BufferPtr += Size;
 
  //
  // Read overrun
  //
  if (Offset != 0) {
    Status = FatGetCacheBlock (PrivateData, BlockDeviceNo, OverRunLba, &CachePtr);
    if (EFI_ERROR (Status)) {
      return EFI_DEVICE_ERROR;
    }
 
    CopyMem (BufferPtr, CachePtr, Offset);
  }
 
  return Status;
}
 
VOID
EngFatToStr (
  IN UINTN    FatSize,
  IN CHAR8    *Fat,
  OUT CHAR16  *Str
  )
{
  CHAR16  *String;
 
  String = Str;
  //
  // No DBCS issues, just expand and add null terminate to end of string
  //
  while (*Fat != 0 && FatSize != 0) {
    if (*Fat == ' ') {
      break;
    }
 
    *String  = *Fat;
    String  += 1;
    Fat     += 1;
    FatSize -= 1;
  }
 
  *String = 0;
}
 
BOOLEAN
EngStriColl (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN CHAR16                 *Str1,
  IN CHAR16                 *Str2
  )
{
  CHAR16  UpperS1;
  CHAR16  UpperS2;
 
  UpperS1 = ToUpper (*Str1);
  UpperS2 = ToUpper (*Str2);
  while (*Str1 != 0) {
    if (UpperS1 != UpperS2) {
      return FALSE;
    }
 
    Str1++;
    Str2++;
    UpperS1 = ToUpper (*Str1);
    UpperS2 = ToUpper (*Str2);
  }
 
  return (BOOLEAN)((*Str2 != 0) ? FALSE : TRUE);
}