FatPkg/FatPei/FatLiteLib.c

   1 /** @file
   2   General purpose supporting routines for FAT recovery PEIM
   3
   4 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
   5
   6 This program and the accompanying materials are licensed and made available
   7 under the terms and conditions of the BSD License which accompanies this
   8 distribution. The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "FatLitePeim.h"
  17
  18
  19 #define CHAR_FAT_VALID  0x01
  20
  21
  22 /**
  23   Converts a union code character to upper case.
  24   This functions converts a unicode character to upper case.
  25   If the input Letter is not a lower-cased letter,
  26   the original value is returned.
  27
  28   @param  Letter            The input unicode character.
  29
  30   @return The upper cased letter.
  31
  32 **/
  33 CHAR16
  34 ToUpper (
  35   IN CHAR16                    Letter
  36   )
  37 {
  38   if ('a' <= Letter && Letter <= 'z') {
  39     Letter = (CHAR16) (Letter - 0x20);
  40   }
  41
  42   return Letter;
  43 }
  44
  45
  46 /**
  47   Reads a block of data from the block device by calling
  48   underlying Block I/O service.
  49
  50   @param  PrivateData       Global memory map for accessing global variables
  51   @param  BlockDeviceNo     The index for the block device number.
  52   @param  Lba               The logic block address to read data from.
  53   @param  BufferSize        The size of data in byte to read.
  54   @param  Buffer            The buffer of the
  55
  56   @retval EFI_DEVICE_ERROR  The specified block device number exceeds the maximum
  57                             device number.
  58   @retval EFI_DEVICE_ERROR  The maximum address has exceeded the maximum address
  59                             of the block device.
  60
  61 **/
  62 EFI_STATUS
  63 FatReadBlock (
  64   IN  PEI_FAT_PRIVATE_DATA   *PrivateData,
  65   IN  UINTN                  BlockDeviceNo,
  66   IN  EFI_PEI_LBA            Lba,
  67   IN  UINTN                  BufferSize,
  68   OUT VOID                   *Buffer
  69   )
  70 {
  71   EFI_STATUS            Status;
  72   PEI_FAT_BLOCK_DEVICE  *BlockDev;
  73
  74   if (BlockDeviceNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
  75     return EFI_DEVICE_ERROR;
  76   }
  77
  78   Status    = EFI_SUCCESS;
  79   BlockDev  = &(PrivateData->BlockDevice[BlockDeviceNo]);
  80
  81   if (BufferSize > MultU64x32 (BlockDev->LastBlock - Lba + 1, BlockDev->BlockSize)) {
  82     return EFI_DEVICE_ERROR;
  83   }
  84
  85   if (!BlockDev->Logical) {
  86     //
  87     // Status = BlockDev->ReadFunc
  88     //  (PrivateData->PeiServices, BlockDev->PhysicalDevNo, Lba, BufferSize, Buffer);
  89     //
  90     if (BlockDev->BlockIo2 != NULL) {
  91       Status = BlockDev->BlockIo2->ReadBlocks (
  92                                     (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (),
  93                                     BlockDev->BlockIo2,
  94                                     BlockDev->PhysicalDevNo,
  95                                     Lba,
  96                                     BufferSize,
  97                                     Buffer
  98                                     );
  99     } else {
 100       Status = BlockDev->BlockIo->ReadBlocks (
 101                                   (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (),
 102                                   BlockDev->BlockIo,
 103                                   BlockDev->PhysicalDevNo,
 104                                   Lba,
 105                                   BufferSize,
 106                                   Buffer
 107                                   );
 108     }
 109
 110   } else {
 111     Status = FatReadDisk (
 112               PrivateData,
 113               BlockDev->ParentDevNo,
 114               BlockDev->StartingPos + MultU64x32 (Lba, BlockDev->BlockSize),
 115               BufferSize,
 116               Buffer
 117               );
 118   }
 119
 120   return Status;
 121 }
 122
 123
 124 /**
 125   Find a cache block designated to specific Block device and Lba.
 126   If not found, invalidate an oldest one and use it. (LRU cache)
 127
 128   @param  PrivateData       the global memory map.
 129   @param  BlockDeviceNo     the Block device.
 130   @param  Lba               the Logical Block Address
 131   @param  CachePtr          Ptr to the starting address of the memory holding the
 132                             data;
 133
 134   @retval EFI_SUCCESS       The function completed successfully.
 135   @retval EFI_DEVICE_ERROR  Something error while accessing media.
 136
 137 **/
 138 EFI_STATUS
 139 FatGetCacheBlock (
 140   IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
 141   IN  UINTN                 BlockDeviceNo,
 142   IN  UINT64                Lba,
 143   OUT CHAR8                 **CachePtr
 144   )
 145 {
 146   EFI_STATUS            Status;
 147   PEI_FAT_CACHE_BUFFER  *CacheBuffer;
 148   INTN                  Index;
 149   STATIC UINT8          Seed;
 150
 151   Status      = EFI_SUCCESS;
 152   CacheBuffer = NULL;
 153
 154   //
 155   // go through existing cache buffers
 156   //
 157   for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
 158     CacheBuffer = &(PrivateData->CacheBuffer[Index]);
 159     if (CacheBuffer->Valid && CacheBuffer->BlockDeviceNo == BlockDeviceNo && CacheBuffer->Lba == Lba) {
 160       break;
 161     }
 162   }
 163
 164   if (Index < PEI_FAT_CACHE_SIZE) {
 165     *CachePtr = (CHAR8 *) CacheBuffer->Buffer;
 166     return EFI_SUCCESS;
 167   }
 168   //
 169   // We have to find an invalid cache buffer
 170   //
 171   for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
 172     if (!PrivateData->CacheBuffer[Index].Valid) {
 173       break;
 174     }
 175   }
 176   //
 177   // Use the cache buffer
 178   //
 179   if (Index == PEI_FAT_CACHE_SIZE) {
 180     Index = (Seed++) % PEI_FAT_CACHE_SIZE;
 181   }
 182
 183   //
 184   // Current device ID should be less than maximum device ID.
 185   //
 186   if (BlockDeviceNo >= PEI_FAT_MAX_BLOCK_DEVICE) {
 187     return EFI_DEVICE_ERROR;
 188   }
 189
 190   CacheBuffer                 = &(PrivateData->CacheBuffer[Index]);
 191
 192   CacheBuffer->BlockDeviceNo  = BlockDeviceNo;
 193   CacheBuffer->Lba            = Lba;
 194   CacheBuffer->Size           = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;
 195
 196   //
 197   // Read in the data
 198   //
 199   Status = FatReadBlock (
 200             PrivateData,
 201             BlockDeviceNo,
 202             Lba,
 203             CacheBuffer->Size,
 204             CacheBuffer->Buffer
 205             );
 206   if (EFI_ERROR (Status)) {
 207     return EFI_DEVICE_ERROR;
 208   }
 209
 210   CacheBuffer->Valid  = TRUE;
 211   *CachePtr           = (CHAR8 *) CacheBuffer->Buffer;
 212
 213   return Status;
 214 }
 215
 216
 217 /**
 218   Disk reading.
 219
 220   @param  PrivateData       the global memory map;
 221   @param  BlockDeviceNo     the block device to read;
 222   @param  StartingAddress   the starting address.
 223   @param  Size              the amount of data to read.
 224   @param  Buffer            the buffer holding the data
 225
 226   @retval EFI_SUCCESS       The function completed successfully.
 227   @retval EFI_DEVICE_ERROR  Something error.
 228
 229 **/
 230 EFI_STATUS
 231 FatReadDisk (
 232   IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
 233   IN  UINTN                 BlockDeviceNo,
 234   IN  UINT64                StartingAddress,
 235   IN  UINTN                 Size,
 236   OUT VOID                  *Buffer
 237   )
 238 {
 239   EFI_STATUS  Status;
 240   UINT32      BlockSize;
 241   CHAR8       *BufferPtr;
 242   CHAR8       *CachePtr;
 243   UINT32      Offset;
 244   UINT64      Lba;
 245   UINT64      OverRunLba;
 246   UINTN       Amount;
 247
 248   Status    = EFI_SUCCESS;
 249   BufferPtr = Buffer;
 250   BlockSize = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;
 251
 252   //
 253   // Read underrun
 254   //
 255   Lba     = DivU64x32Remainder (StartingAddress, BlockSize, &Offset);
 256   Status  = FatGetCacheBlock (PrivateData, BlockDeviceNo, Lba, &CachePtr);
 257   if (EFI_ERROR (Status)) {
 258     return EFI_DEVICE_ERROR;
 259   }
 260
 261   Amount = Size < (BlockSize - Offset) ? Size : (BlockSize - Offset);
 262   CopyMem (BufferPtr, CachePtr + Offset, Amount);
 263
 264   if (Size == Amount) {
 265     return EFI_SUCCESS;
 266   }
 267
 268   Size -= Amount;
 269   BufferPtr += Amount;
 270   StartingAddress += Amount;
 271   Lba += 1;
 272
 273   //
 274   // Read aligned parts
 275   //
 276   OverRunLba = Lba + DivU64x32Remainder (Size, BlockSize, &Offset);
 277
 278   Size -= Offset;
 279   Status = FatReadBlock (PrivateData, BlockDeviceNo, Lba, Size, BufferPtr);
 280   if (EFI_ERROR (Status)) {
 281     return EFI_DEVICE_ERROR;
 282   }
 283
 284   BufferPtr += Size;
 285
 286   //
 287   // Read overrun
 288   //
 289   if (Offset != 0) {
 290     Status = FatGetCacheBlock (PrivateData, BlockDeviceNo, OverRunLba, &CachePtr);
 291     if (EFI_ERROR (Status)) {
 292       return EFI_DEVICE_ERROR;
 293     }
 294
 295     CopyMem (BufferPtr, CachePtr, Offset);
 296   }
 297
 298   return Status;
 299 }
 300
 301
 302 /**
 303   This version is different from the version in Unicode collation
 304   protocol in that this version strips off trailing blanks.
 305   Converts an 8.3 FAT file name using an OEM character set
 306   to a Null-terminated Unicode string.
 307   Here does not expand DBCS FAT chars.
 308
 309   @param  FatSize           The size of the string Fat in bytes.
 310   @param  Fat               A pointer to a Null-terminated string that contains
 311                             an 8.3 file name using an OEM character set.
 312   @param  Str               A pointer to a Null-terminated Unicode string. The
 313                             string must be allocated in advance to hold FatSize
 314                             Unicode characters
 315
 316 **/
 317 VOID
 318 EngFatToStr (
 319   IN UINTN                            FatSize,
 320   IN CHAR8                            *Fat,
 321   OUT CHAR16                          *Str
 322   )
 323 {
 324   CHAR16  *String;
 325
 326   String = Str;
 327   //
 328   // No DBCS issues, just expand and add null terminate to end of string
 329   //
 330   while (*Fat != 0 && FatSize != 0) {
 331     if (*Fat == ' ') {
 332       break;
 333     }
 334     *String = *Fat;
 335     String += 1;
 336     Fat += 1;
 337     FatSize -= 1;
 338   }
 339
 340   *String = 0;
 341 }
 342
 343
 344 /**
 345   Performs a case-insensitive comparison of two Null-terminated Unicode strings.
 346
 347   @param  PrivateData       Global memory map for accessing global variables
 348   @param  Str1              First string to perform case insensitive comparison.
 349   @param  Str2              Second string to perform case insensitive comparison.
 350
 351 **/
 352 BOOLEAN
 353 EngStriColl (
 354   IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
 355   IN CHAR16                 *Str1,
 356   IN CHAR16                 *Str2
 357   )
 358 {
 359   CHAR16  UpperS1;
 360   CHAR16  UpperS2;
 361
 362   UpperS1 = ToUpper (*Str1);
 363   UpperS2 = ToUpper (*Str2);
 364   while (*Str1 != 0) {
 365     if (UpperS1 != UpperS2) {
 366       return FALSE;
 367     }
 368
 369     Str1++;
 370     Str2++;
 371     UpperS1 = ToUpper (*Str1);
 372     UpperS2 = ToUpper (*Str2);
 373   }
 374
 375   return (BOOLEAN) ((*Str2 != 0) ? FALSE : TRUE);
 376 }