FatLitePeim.h

Go to the documentation of this file.

 
#ifndef _FAT_PEIM_H_
#define _FAT_PEIM_H_
 
#include <PiPei.h>
 
#include <Guid/RecoveryDevice.h>
#include <Ppi/BlockIo.h>
#include <Ppi/BlockIo2.h>
#include <Ppi/DeviceRecoveryModule.h>
 
#include <Library/DebugLib.h>
#include <Library/BaseLib.h>
#include <Library/PeimEntryPoint.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PcdLib.h>
#include <Library/PeiServicesTablePointerLib.h>
#include <Library/PeiServicesLib.h>
 
#include "FatLiteApi.h"
#include "FatLiteFmt.h"
 
//
// Definitions
//
 
#define PEI_FAT_CACHE_SIZE        4
#define PEI_FAT_MAX_BLOCK_SIZE    8192
#define FAT_MAX_FILE_NAME_LENGTH  128
#define PEI_FAT_MAX_BLOCK_DEVICE  64
#define PEI_FAT_MAX_BLOCK_IO_PPI  32
#define PEI_FAT_MAX_VOLUME        64
 
#define PEI_FAT_MEMORY_PAGE_SIZE  0x1000
 
//
// Data Structures
//
//
// The block device
//
typedef struct {
  UINT32                            BlockSize;
  UINT64                            LastBlock;
  UINT32                            IoAlign;
  BOOLEAN                           Logical;
  BOOLEAN                           PartitionChecked;
 
  //
  // Following fields only valid for logical device
  //
  CHAR8                             PartitionFlag[8];
  UINT64                            StartingPos;
  UINTN                             ParentDevNo;
 
  //
  // Following fields only valid for physical device
  //
  EFI_PEI_BLOCK_DEVICE_TYPE         DevType;
  UINT8                             InterfaceType;
  //
  // EFI_PEI_READ_BLOCKS         ReadFunc;
  //
  EFI_PEI_RECOVERY_BLOCK_IO_PPI     *BlockIo;
  EFI_PEI_RECOVERY_BLOCK_IO2_PPI    *BlockIo2;
  UINT8                             PhysicalDevNo;
} PEI_FAT_BLOCK_DEVICE;
 
//
// the Volume structure
//
typedef struct {
  UINTN           BlockDeviceNo;
  UINTN           VolumeNo;
  UINT64          VolumeSize;
  UINTN           MaxCluster;
  CHAR16          VolumeLabel[FAT_MAX_FILE_NAME_LENGTH];
  PEI_FAT_TYPE    FatType;
  UINT64          FatPos;
  UINT32          SectorSize;
  UINT32          ClusterSize;
  UINT64          FirstClusterPos;
  UINT64          RootDirPos;
  UINT32          RootEntries;
  UINT32          RootDirCluster;
} PEI_FAT_VOLUME;
 
//
// File instance
//
typedef struct {
  PEI_FAT_VOLUME    *Volume;
  CHAR16            FileName[FAT_MAX_FILE_NAME_LENGTH];
 
  BOOLEAN           IsFixedRootDir;
 
  UINT32            StartingCluster;
  UINT32            CurrentPos;
  UINT32            StraightReadAmount;
  UINT32            CurrentCluster;
 
  UINT8             Attributes;
  UINT32            FileSize;
} PEI_FAT_FILE;
 
//
// Cache Buffer
//
typedef struct {
  BOOLEAN    Valid;
  UINTN      BlockDeviceNo;
  UINT64     Lba;
  UINT32     Lru;
  UINT64     Buffer[PEI_FAT_MAX_BLOCK_SIZE / 8];
  UINTN      Size;
} PEI_FAT_CACHE_BUFFER;
 
//
// Private Data.
// This structure abstracts the whole memory usage in FAT PEIM.
// The entry point routine will get a chunk of memory (by whatever
// means) whose size is sizeof(PEI_FAT_PRIVATE_DATA), which is clean
// in both 32 and 64 bit environment. The boundary of the memory chunk
// should be 64bit aligned.
//
#define PEI_FAT_PRIVATE_DATA_SIGNATURE  SIGNATURE_32 ('p', 'f', 'a', 't')
 
typedef struct {
  UINTN                                 Signature;
  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI    DeviceRecoveryPpi;
  EFI_PEI_PPI_DESCRIPTOR                PpiDescriptor;
  EFI_PEI_NOTIFY_DESCRIPTOR             NotifyDescriptor[2];
 
  UINT8                                 UnicodeCaseMap[0x300];
  CHAR8                                 *EngUpperMap;
  CHAR8                                 *EngLowerMap;
  CHAR8                                 *EngInfoMap;
 
  UINT64                                BlockData[PEI_FAT_MAX_BLOCK_SIZE / 8];
  UINTN                                 BlockDeviceCount;
  PEI_FAT_BLOCK_DEVICE                  BlockDevice[PEI_FAT_MAX_BLOCK_DEVICE];
  UINTN                                 VolumeCount;
  PEI_FAT_VOLUME                        Volume[PEI_FAT_MAX_VOLUME];
  PEI_FAT_FILE                          File;
  PEI_FAT_CACHE_BUFFER                  CacheBuffer[PEI_FAT_CACHE_SIZE];
} PEI_FAT_PRIVATE_DATA;
 
#define PEI_FAT_PRIVATE_DATA_FROM_THIS(a) \
  CR (a,  PEI_FAT_PRIVATE_DATA, DeviceRecoveryPpi, PEI_FAT_PRIVATE_DATA_SIGNATURE)
 
//
// Extract INT32 from char array
//
#define UNPACK_INT32(a) \
  (INT32) ((((UINT8 *) a)[0] << 0) | (((UINT8 *) a)[1] << 8) | (((UINT8 *) a)[2] << 16) | (((UINT8 *) a)[3] << 24))
 
//
// Extract UINT32 from char array
//
#define UNPACK_UINT32(a) \
  (UINT32) ((((UINT8 *) a)[0] << 0) | (((UINT8 *) a)[1] << 8) | (((UINT8 *) a)[2] << 16) | (((UINT8 *) a)[3] << 24))
 
//
// API functions
//
 
EFI_STATUS
FindRecoveryFile (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  UINTN                 VolumeIndex,
  IN  CHAR16                *FileName,
  OUT PEI_FILE_HANDLE       *Handle
  );
 
EFI_STATUS
EFIAPI
GetNumberRecoveryCapsules (
  IN EFI_PEI_SERVICES                    **PeiServices,
  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  *This,
  OUT UINTN                              *NumberRecoveryCapsules
  );
 
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
EFIAPI
LoadRecoveryCapsule (
  IN EFI_PEI_SERVICES                    **PeiServices,
  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  *This,
  IN UINTN                               CapsuleInstance,
  OUT VOID                               *Buffer
  );
 
VOID
EngFatToStr (
  IN UINTN    FatSize,
  IN CHAR8    *Fat,
  OUT CHAR16  *Str
  );
 
BOOLEAN
EngStriColl (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN CHAR16                 *Str1,
  IN CHAR16                 *Str2
  );
 
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
FatGetBpbInfo (
  IN      PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN OUT  PEI_FAT_VOLUME        *Volume
  );
 
EFI_STATUS
FatGetNextCluster (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  PEI_FAT_VOLUME        *Volume,
  IN  UINT32                Cluster,
  OUT UINT32                *NextCluster
  );
 
EFI_STATUS
FatReadDisk (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  UINTN                 BlockDeviceNo,
  IN  UINT64                StartingAddress,
  IN  UINTN                 Size,
  OUT VOID                  *Buffer
  );
 
EFI_STATUS
FatSetFilePos (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  PEI_FAT_FILE          *File,
  IN  UINT32                Pos
  );
 
EFI_STATUS
FatReadFile (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  PEI_FAT_FILE          *File,
  IN  UINTN                 Size,
  OUT VOID                  *Buffer
  );
 
EFI_STATUS
FatReadNextDirectoryEntry (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
  IN  PEI_FAT_FILE          *ParentDir,
  OUT PEI_FAT_FILE          *SubFile
  );
 
VOID
FatFindPartitions (
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData
  );
 
#endif // _FAT_PEIM_H_