[mirror_edk2.git] / FatPkg / FatPei / FatLitePeim.h

/** @file\r
  Data structures for FAT recovery PEIM\r
\r
Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>\r
\r
This program and the accompanying materials are licensed and made available\r
under the terms and conditions of the BSD License which accompanies this\r
distribution. The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#ifndef _FAT_PEIM_H_\r
#define _FAT_PEIM_H_\r
\r
#include <PiPei.h>\r
\r
#include <Guid/RecoveryDevice.h>\r
#include <Ppi/BlockIo.h>\r
#include <Ppi/BlockIo2.h>\r
#include <Ppi/DeviceRecoveryModule.h>\r
\r
#include <Library/DebugLib.h>\r
#include <Library/BaseLib.h>\r
#include <Library/PeimEntryPoint.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/PcdLib.h>\r
#include <Library/PeiServicesTablePointerLib.h>\r
#include <Library/PeiServicesLib.h>\r
\r
#include "FatLiteApi.h"\r
#include "FatLiteFmt.h"\r
\r
//\r
// Definitions\r
//\r
\r
#define PEI_FAT_CACHE_SIZE                            4\r
#define PEI_FAT_MAX_BLOCK_SIZE                        8192\r
#define FAT_MAX_FILE_NAME_LENGTH                      128\r
#define PEI_FAT_MAX_BLOCK_DEVICE                      64\r
#define PEI_FAT_MAX_BLOCK_IO_PPI                      32\r
#define PEI_FAT_MAX_VOLUME                            64\r
\r
#define PEI_FAT_MEMMORY_PAGE_SIZE                     0x1000\r
\r
//\r
// Data Structures\r
//\r
//\r
// The block device\r
//\r
typedef struct {\r
\r
  UINT32                        BlockSize;\r
  UINT64                        LastBlock;\r
  UINT32                        IoAlign;\r
  BOOLEAN                       Logical;\r
  BOOLEAN                       PartitionChecked;\r
\r
  //\r
  // Following fields only valid for logical device\r
  //\r
  CHAR8                         PartitionFlag[8];\r
  UINT64                        StartingPos;\r
  UINTN                         ParentDevNo;\r
\r
  //\r
  // Following fields only valid for physical device\r
  //\r
  EFI_PEI_BLOCK_DEVICE_TYPE     DevType;\r
  UINT8                         InterfaceType;\r
  //\r
  // EFI_PEI_READ_BLOCKS         ReadFunc;\r
  //\r
  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *BlockIo;\r
  EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2;\r
  UINT8                          PhysicalDevNo;\r
} PEI_FAT_BLOCK_DEVICE;\r
\r
//\r
// the Volume structure\r
//\r
typedef struct {\r
\r
  UINTN         BlockDeviceNo;\r
  UINTN         VolumeNo;\r
  UINT64        VolumeSize;\r
  UINTN         MaxCluster;\r
  CHAR16        VolumeLabel[FAT_MAX_FILE_NAME_LENGTH];\r
  PEI_FAT_TYPE  FatType;\r
  UINT64        FatPos;\r
  UINT32        SectorSize;\r
  UINT32        ClusterSize;\r
  UINT64        FirstClusterPos;\r
  UINT64        RootDirPos;\r
  UINT32        RootEntries;\r
  UINT32        RootDirCluster;\r
\r
} PEI_FAT_VOLUME;\r
\r
//\r
// File instance\r
//\r
typedef struct {\r
\r
  PEI_FAT_VOLUME  *Volume;\r
  CHAR16          FileName[FAT_MAX_FILE_NAME_LENGTH];\r
\r
  BOOLEAN         IsFixedRootDir;\r
\r
  UINT32          StartingCluster;\r
  UINT32          CurrentPos;\r
  UINT32          StraightReadAmount;\r
  UINT32          CurrentCluster;\r
\r
  UINT8           Attributes;\r
  UINT32          FileSize;\r
\r
} PEI_FAT_FILE;\r
\r
//\r
// Cache Buffer\r
//\r
typedef struct {\r
\r
  BOOLEAN Valid;\r
  UINTN   BlockDeviceNo;\r
  UINT64  Lba;\r
  UINT32  Lru;\r
  UINT64  Buffer[PEI_FAT_MAX_BLOCK_SIZE / 8];\r
  UINTN   Size;\r
\r
} PEI_FAT_CACHE_BUFFER;\r
\r
//\r
// Private Data.\r
// This structure abstracts the whole memory usage in FAT PEIM.\r
// The entry point routine will get a chunk of memory (by whatever\r
// means) whose size is sizeof(PEI_FAT_PRIVATE_DATA), which is clean\r
// in both 32 and 64 bit environment. The boundary of the memory chunk\r
// should be 64bit aligned.\r
//\r
#define PEI_FAT_PRIVATE_DATA_SIGNATURE  SIGNATURE_32 ('p', 'f', 'a', 't')\r
\r
typedef struct {\r
\r
  UINTN                               Signature;\r
  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  DeviceRecoveryPpi;\r
  EFI_PEI_PPI_DESCRIPTOR              PpiDescriptor;\r
  EFI_PEI_NOTIFY_DESCRIPTOR           NotifyDescriptor[2];\r
\r
  UINT8                               UnicodeCaseMap[0x300];\r
  CHAR8                               *EngUpperMap;\r
  CHAR8                               *EngLowerMap;\r
  CHAR8                               *EngInfoMap;\r
\r
  UINT64                              BlockData[PEI_FAT_MAX_BLOCK_SIZE / 8];\r
  UINTN                               BlockDeviceCount;\r
  PEI_FAT_BLOCK_DEVICE                BlockDevice[PEI_FAT_MAX_BLOCK_DEVICE];\r
  UINTN                               VolumeCount;\r
  PEI_FAT_VOLUME                      Volume[PEI_FAT_MAX_VOLUME];\r
  PEI_FAT_FILE                        File;\r
  PEI_FAT_CACHE_BUFFER                CacheBuffer[PEI_FAT_CACHE_SIZE];\r
\r
} PEI_FAT_PRIVATE_DATA;\r
\r
#define PEI_FAT_PRIVATE_DATA_FROM_THIS(a) \\r
  CR (a,  PEI_FAT_PRIVATE_DATA, DeviceRecoveryPpi, PEI_FAT_PRIVATE_DATA_SIGNATURE)\r
\r
//\r
// Extract INT32 from char array\r
//\r
#define UNPACK_INT32(a) \\r
  (INT32) ((((UINT8 *) a)[0] << 0) | (((UINT8 *) a)[1] << 8) | (((UINT8 *) a)[2] << 16) | (((UINT8 *) a)[3] << 24))\r
\r
//\r
// Extract UINT32 from char array\r
//\r
#define UNPACK_UINT32(a) \\r
  (UINT32) ((((UINT8 *) a)[0] << 0) | (((UINT8 *) a)[1] << 8) | (((UINT8 *) a)[2] << 16) | (((UINT8 *) a)[3] << 24))\r
\r
\r
//\r
// API functions\r
//\r
\r
/**\r
  Finds the recovery file on a FAT volume.\r
  This function finds the the recovery file named FileName on a specified FAT volume and returns\r
  its FileHandle pointer.\r
\r
  @param  PrivateData             Global memory map for accessing global\r
                                  variables.\r
  @param  VolumeIndex             The index of the volume.\r
  @param  FileName                The recovery file name to find.\r
  @param  Handle                  The output file handle.\r
\r
  @retval EFI_DEVICE_ERROR        Some error occured when operating the FAT\r
                                  volume.\r
  @retval EFI_NOT_FOUND           The recovery file was not found.\r
  @retval EFI_SUCCESS             The recovery file was successfully found on the\r
                                  FAT volume.\r
\r
**/\r
EFI_STATUS\r
FindRecoveryFile (\r
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,\r
  IN  UINTN                 VolumeIndex,\r
  IN  CHAR16                *FileName,\r
  OUT PEI_FILE_HANDLE       *Handle\r
  );\r
\r
\r
/**\r
  Returns the number of DXE capsules residing on the device.\r
  This function, by whatever mechanism, searches for DXE capsules from the associated device and\r
  returns the number and maximum size in bytes of the capsules discovered.Entry 1 is assumed to be\r
  the highest load priority and entry N is assumed to be the lowest priority.\r
\r
  @param  PeiServices             General-purpose services that are available to\r
                                  every PEIM.\r
  @param  This                    Indicates the\r
                                  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI instance.\r
  @param  NumberRecoveryCapsules  Pointer to a caller-allocated UINTN.On output,\r
                                  *NumberRecoveryCapsules contains the number of\r
                                  recovery capsule images available for retrieval\r
                                  from this PEIM instance.\r
\r
  @retval EFI_SUCCESS             The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
GetNumberRecoveryCapsules (\r
  IN EFI_PEI_SERVICES                               **PeiServices,\r
  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI             *This,\r
  OUT UINTN                                         *NumberRecoveryCapsules\r
  );\r
\r
\r
/**\r
  Returns the size and type of the requested recovery capsule.\r
  This function returns the size and type of the capsule specified by CapsuleInstance.\r
\r
  @param  PeiServices             General-purpose services that are available to\r
                                  every PEIM.\r
  @param  This                    Indicates the\r
                                  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI instance.\r
  @param  CapsuleInstance         Specifies for which capsule instance to\r
                                  retrieve the information.T his parameter must\r
                                  be between one and the value returned by\r
                                  GetNumberRecoveryCapsules() in\r
                                  NumberRecoveryCapsules.\r
  @param  Size                    A pointer to a caller-allocated UINTN in which\r
                                  the size of the requested recovery module is\r
                                  returned.\r
  @param  CapsuleType             A pointer to a caller-allocated EFI_GUID in\r
                                  which the type of the requested recovery\r
                                  capsule is returned.T he semantic meaning of\r
                                  the value returned is defined by the\r
                                  implementation.\r
\r
  @retval EFI_SUCCESS             The capsule type and size were retrieved.\r
  @retval EFI_INVALID_PARAMETER   The input CapsuleInstance does not match any\r
                                  discovered recovery capsule.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
GetRecoveryCapsuleInfo (\r
  IN  EFI_PEI_SERVICES                              **PeiServices,\r
  IN  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI            *This,\r
  IN  UINTN                                         CapsuleInstance,\r
  OUT UINTN                                         *Size,\r
  OUT EFI_GUID                                      *CapsuleType\r
  );\r
\r
\r
/**\r
  Loads a DXE capsule from some media into memory.\r
\r
  This function, by whatever mechanism, retrieves a DXE capsule from some device\r
  and loads it into memory. Note that the published interface is device neutral.\r
\r
  @param[in]     PeiServices       General-purpose services that are available\r
                                   to every PEIM\r
  @param[in]     This              Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI\r
                                   instance.\r
  @param[in]     CapsuleInstance   Specifies which capsule instance to retrieve.\r
  @param[out]    Buffer            Specifies a caller-allocated buffer in which\r
                                   the requested recovery capsule will be returned.\r
\r
  @retval EFI_SUCCESS        The capsule was loaded correctly.\r
  @retval EFI_DEVICE_ERROR   A device error occurred.\r
  @retval EFI_NOT_FOUND      A requested recovery DXE capsule cannot be found.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
LoadRecoveryCapsule (\r
  IN EFI_PEI_SERVICES                             **PeiServices,\r
  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI           *This,\r
  IN UINTN                                        CapsuleInstance,\r
  OUT VOID                                        *Buffer\r
  );\r
\r
\r
/**\r
  This version is different from the version in Unicode collation\r
  protocol in that this version strips off trailing blanks.\r
  Converts an 8.3 FAT file name using an OEM character set\r
  to a Null-terminated Unicode string.\r
  Here does not expand DBCS FAT chars.\r
\r
  @param  FatSize           The size of the string Fat in bytes.\r
  @param  Fat               A pointer to a Null-terminated string that contains\r
                            an 8.3 file name using an OEM character set.\r
  @param  Str               A pointer to a Null-terminated Unicode string. The\r
                            string must be allocated in advance to hold FatSize\r
                            Unicode characters\r
\r
**/\r
VOID\r
EngFatToStr (\r
  IN UINTN                            FatSize,\r
  IN CHAR8                            *Fat,\r
  OUT CHAR16                          *Str\r
  );\r
\r
\r
/**\r
  Performs a case-insensitive comparison of two Null-terminated Unicode strings.\r
\r
  @param  PrivateData       Global memory map for accessing global variables\r
  @param  Str1              First string to perform case insensitive comparison.\r
  @param  Str2              Second string to perform case insensitive comparison.\r
\r
**/\r
BOOLEAN\r
EngStriColl (\r
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,\r
  IN CHAR16                 *Str1,\r
  IN CHAR16                 *Str2\r
  );\r
\r
\r
/**\r
  Reads a block of data from the block device by calling\r
  underlying Block I/O service.\r
\r
  @param  PrivateData       Global memory map for accessing global variables\r
  @param  BlockDeviceNo     The index for the block device number.\r
  @param  Lba               The logic block address to read data from.\r
  @param  BufferSize        The size of data in byte to read.\r
  @param  Buffer            The buffer of the\r
\r
  @retval EFI_DEVICE_ERROR  The specified block device number exceeds the maximum\r
                            device number.\r
  @retval EFI_DEVICE_ERROR  The maximum address has exceeded the maximum address\r
                            of the block device.\r
\r
**/\r
EFI_STATUS\r
FatReadBlock (\r
  IN  PEI_FAT_PRIVATE_DATA   *PrivateData,\r
  IN  UINTN                  BlockDeviceNo,\r
  IN  EFI_PEI_LBA            Lba,\r
  IN  UINTN                  BufferSize,\r
  OUT VOID                   *Buffer\r
  );\r
\r
\r
/**\r
  Check if there is a valid FAT in the corresponding Block device\r
  of the volume and if yes, fill in the relevant fields for the\r
  volume structure. Note there should be a valid Block device number\r
  already set.\r
\r
  @param  PrivateData            Global memory map for accessing global\r
                                 variables.\r
  @param  Volume                 On input, the BlockDeviceNumber field of the\r
                                 Volume  should be a valid value. On successful\r
                                 output, all  fields except the VolumeNumber\r
                                 field is initialized.\r
\r
  @retval EFI_SUCCESS            A FAT is found and the volume structure is\r
                                 initialized.\r
  @retval EFI_NOT_FOUND          There is no FAT on the corresponding device.\r
  @retval EFI_DEVICE_ERROR       There is something error while accessing device.\r
\r
**/\r
EFI_STATUS\r
FatGetBpbInfo (\r
  IN      PEI_FAT_PRIVATE_DATA  *PrivateData,\r
  IN OUT  PEI_FAT_VOLUME        *Volume\r
  );\r
\r
\r
/**\r
  Gets the next cluster in the cluster chain.\r
\r
  @param  PrivateData            Global memory map for accessing global variables\r
  @param  Volume                 The volume\r
  @param  Cluster                The cluster\r
  @param  NextCluster            The cluster number of the next cluster\r
\r
  @retval EFI_SUCCESS            The address is got\r
  @retval EFI_INVALID_PARAMETER  ClusterNo exceeds the MaxCluster of the volume.\r
  @retval EFI_DEVICE_ERROR       Read disk error\r
\r
**/\r
EFI_STATUS\r
FatGetNextCluster (\r
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,\r
  IN  PEI_FAT_VOLUME        *Volume,\r
  IN  UINT32                Cluster,\r
  OUT UINT32                *NextCluster\r
  );\r
\r
\r
/**\r
  Disk reading.\r
\r
  @param  PrivateData       the global memory map;\r
  @param  BlockDeviceNo     the block device to read;\r
  @param  StartingAddress   the starting address.\r
  @param  Size              the amount of data to read.\r
  @param  Buffer            the buffer holding the data\r
\r
  @retval EFI_SUCCESS       The function completed successfully.\r
  @retval EFI_DEVICE_ERROR  Something error.\r
\r
**/\r
EFI_STATUS\r
FatReadDisk (\r
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,\r
  IN  UINTN                 BlockDeviceNo,\r
  IN  UINT64                StartingAddress,\r
  IN  UINTN                 Size,\r
  OUT VOID                  *Buffer\r
  );\r
\r
\r
/**\r
  Set a file's CurrentPos and CurrentCluster, then compute StraightReadAmount.\r
\r
  @param  PrivateData            the global memory map\r
  @param  File                   the file\r
  @param  Pos                    the Position which is offset from the file's\r
                                 CurrentPos\r
\r
  @retval EFI_SUCCESS            Success.\r
  @retval EFI_INVALID_PARAMETER  Pos is beyond file's size.\r
  @retval EFI_DEVICE_ERROR       Something error while accessing media.\r
\r
**/\r
EFI_STATUS\r
FatSetFilePos (\r
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,\r
  IN  PEI_FAT_FILE          *File,\r
  IN  UINT32                Pos\r
  );\r
\r
\r
/**\r
  Reads file data. Updates the file's CurrentPos.\r
\r
  @param  PrivateData            Global memory map for accessing global variables\r
  @param  File                   The file.\r
  @param  Size                   The amount of data to read.\r
  @param  Buffer                 The buffer storing the data.\r
\r
  @retval EFI_SUCCESS            The data is read.\r
  @retval EFI_INVALID_PARAMETER  File is invalid.\r
  @retval EFI_DEVICE_ERROR       Something error while accessing media.\r
\r
**/\r
EFI_STATUS\r
FatReadFile (\r
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,\r
  IN  PEI_FAT_FILE          *File,\r
  IN  UINTN                 Size,\r
  OUT VOID                  *Buffer\r
  );\r
\r
\r
/**\r
  This function reads the next item in the parent directory and\r
  initializes the output parameter SubFile (CurrentPos is initialized to 0).\r
  The function updates the CurrentPos of the parent dir to after the item read.\r
  If no more items were found, the function returns EFI_NOT_FOUND.\r
\r
  @param  PrivateData            Global memory map for accessing global variables\r
  @param  ParentDir              The parent directory.\r
  @param  SubFile                The File structure containing the sub file that\r
                                 is caught.\r
\r
  @retval EFI_SUCCESS            The next sub file is obtained.\r
  @retval EFI_INVALID_PARAMETER  The ParentDir is not a directory.\r
  @retval EFI_NOT_FOUND          No more sub file exists.\r
  @retval EFI_DEVICE_ERROR       Something error while accessing media.\r
\r
**/\r
EFI_STATUS\r
FatReadNextDirectoryEntry (\r
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,\r
  IN  PEI_FAT_FILE          *ParentDir,\r
  OUT PEI_FAT_FILE          *SubFile\r
  );\r
\r
\r
/**\r
  This function finds partitions (logical devices) in physical block devices.\r
\r
  @param  PrivateData       Global memory map for accessing global variables.\r
\r
**/\r
VOID\r
FatFindPartitions (\r
  IN  PEI_FAT_PRIVATE_DATA  *PrivateData\r
  );\r
\r
#endif // _FAT_PEIM_H_\r
Commit	Line	Data
2f4dfa84 JJ	1	/** @file\r
	2	Data structures for FAT recovery PEIM\r
	3	\r
0d18f5db	4	Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>\r
2f4dfa84 JJ	5	\r
	6	This program and the accompanying materials are licensed and made available\r
	7	under the terms and conditions of the BSD License which accompanies this\r
	8	distribution. The full text of the license may be found at\r
	9	http://opensource.org/licenses/bsd-license.php\r
	10	\r
	11	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	12	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	13	\r
	14	**/\r
	15	\r
	16	#ifndef _FAT_PEIM_H_\r
	17	#define _FAT_PEIM_H_\r
	18	\r
	19	#include <PiPei.h>\r
	20	\r
	21	#include <Guid/RecoveryDevice.h>\r
	22	#include <Ppi/BlockIo.h>\r
8a467be1	23	#include <Ppi/BlockIo2.h>\r
2f4dfa84 JJ	24	#include <Ppi/DeviceRecoveryModule.h>\r
	25	\r
	26	#include <Library/DebugLib.h>\r
	27	#include <Library/BaseLib.h>\r
	28	#include <Library/PeimEntryPoint.h>\r
	29	#include <Library/BaseMemoryLib.h>\r
0d18f5db	30	#include <Library/MemoryAllocationLib.h>\r
2f4dfa84 JJ	31	#include <Library/PcdLib.h>\r
	32	#include <Library/PeiServicesTablePointerLib.h>\r
	33	#include <Library/PeiServicesLib.h>\r
	34	\r
	35	#include "FatLiteApi.h"\r
	36	#include "FatLiteFmt.h"\r
	37	\r
	38	//\r
	39	// Definitions\r
	40	//\r
2f4dfa84 JJ	41	\r
	42	#define PEI_FAT_CACHE_SIZE 4\r
	43	#define PEI_FAT_MAX_BLOCK_SIZE 8192\r
	44	#define FAT_MAX_FILE_NAME_LENGTH 128\r
	45	#define PEI_FAT_MAX_BLOCK_DEVICE 64\r
	46	#define PEI_FAT_MAX_BLOCK_IO_PPI 32\r
	47	#define PEI_FAT_MAX_VOLUME 64\r
	48	\r
	49	#define PEI_FAT_MEMMORY_PAGE_SIZE 0x1000\r
	50	\r
	51	//\r
	52	// Data Structures\r
	53	//\r
	54	//\r
	55	// The block device\r
	56	//\r
	57	typedef struct {\r
	58	\r
	59	UINT32 BlockSize;\r
	60	UINT64 LastBlock;\r
	61	UINT32 IoAlign;\r
	62	BOOLEAN Logical;\r
	63	BOOLEAN PartitionChecked;\r
	64	\r
	65	//\r
	66	// Following fields only valid for logical device\r
	67	//\r
	68	CHAR8 PartitionFlag[8];\r
	69	UINT64 StartingPos;\r
	70	UINTN ParentDevNo;\r
	71	\r
	72	//\r
	73	// Following fields only valid for physical device\r
	74	//\r
	75	EFI_PEI_BLOCK_DEVICE_TYPE DevType;\r
8a467be1	76	UINT8 InterfaceType;\r
2f4dfa84 JJ	77	//\r
	78	// EFI_PEI_READ_BLOCKS ReadFunc;\r
	79	//\r
8a467be1 FT	80	EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIo;\r
	81	EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2;\r
	82	UINT8 PhysicalDevNo;\r
2f4dfa84 JJ	83	} PEI_FAT_BLOCK_DEVICE;\r
	84	\r
	85	//\r
	86	// the Volume structure\r
	87	//\r
	88	typedef struct {\r
	89	\r
	90	UINTN BlockDeviceNo;\r
	91	UINTN VolumeNo;\r
	92	UINT64 VolumeSize;\r
	93	UINTN MaxCluster;\r
	94	CHAR16 VolumeLabel[FAT_MAX_FILE_NAME_LENGTH];\r
	95	PEI_FAT_TYPE FatType;\r
	96	UINT64 FatPos;\r
	97	UINT32 SectorSize;\r
	98	UINT32 ClusterSize;\r
	99	UINT64 FirstClusterPos;\r
	100	UINT64 RootDirPos;\r
	101	UINT32 RootEntries;\r
	102	UINT32 RootDirCluster;\r
	103	\r
	104	} PEI_FAT_VOLUME;\r
	105	\r
	106	//\r
	107	// File instance\r
	108	//\r
	109	typedef struct {\r
	110	\r
	111	PEI_FAT_VOLUME *Volume;\r
	112	CHAR16 FileName[FAT_MAX_FILE_NAME_LENGTH];\r
	113	\r
	114	BOOLEAN IsFixedRootDir;\r
	115	\r
	116	UINT32 StartingCluster;\r
	117	UINT32 CurrentPos;\r
	118	UINT32 StraightReadAmount;\r
	119	UINT32 CurrentCluster;\r
	120	\r
	121	UINT8 Attributes;\r
	122	UINT32 FileSize;\r
	123	\r
	124	} PEI_FAT_FILE;\r
	125	\r
	126	//\r
	127	// Cache Buffer\r
	128	//\r
	129	typedef struct {\r
	130	\r
	131	BOOLEAN Valid;\r
	132	UINTN BlockDeviceNo;\r
	133	UINT64 Lba;\r
	134	UINT32 Lru;\r
	135	UINT64 Buffer[PEI_FAT_MAX_BLOCK_SIZE / 8];\r
	136	UINTN Size;\r
	137	\r
	138	} PEI_FAT_CACHE_BUFFER;\r
	139	\r
	140	//\r
	141	// Private Data.\r
	142	// This structure abstracts the whole memory usage in FAT PEIM.\r
	143	// The entry point routine will get a chunk of memory (by whatever\r
	144	// means) whose size is sizeof(PEI_FAT_PRIVATE_DATA), which is clean\r
	145	// in both 32 and 64 bit environment. The boundary of the memory chunk\r
	146	// should be 64bit aligned.\r
147	//\r
148	#define PEI_FAT_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('p', 'f', 'a', 't')\r
149	\r
150	typedef struct {\r
151	\r
152	UINTN Signature;\r
153	EFI_PEI_DEVICE_RECOVERY_MODULE_PPI DeviceRecoveryPpi;\r
154	EFI_PEI_PPI_DESCRIPTOR PpiDescriptor;\r
8a467be1	155	EFI_PEI_NOTIFY_DESCRIPTOR NotifyDescriptor[2];\r
2f4dfa84 JJ	156	\r
	157	UINT8 UnicodeCaseMap[0x300];\r
	158	CHAR8 *EngUpperMap;\r
	159	CHAR8 *EngLowerMap;\r
	160	CHAR8 *EngInfoMap;\r
	161	\r
	162	UINT64 BlockData[PEI_FAT_MAX_BLOCK_SIZE / 8];\r
	163	UINTN BlockDeviceCount;\r
	164	PEI_FAT_BLOCK_DEVICE BlockDevice[PEI_FAT_MAX_BLOCK_DEVICE];\r
	165	UINTN VolumeCount;\r
	166	PEI_FAT_VOLUME Volume[PEI_FAT_MAX_VOLUME];\r
	167	PEI_FAT_FILE File;\r
	168	PEI_FAT_CACHE_BUFFER CacheBuffer[PEI_FAT_CACHE_SIZE];\r
	169	\r
	170	} PEI_FAT_PRIVATE_DATA;\r
	171	\r
	172	#define PEI_FAT_PRIVATE_DATA_FROM_THIS(a) \\r
	173	CR (a, PEI_FAT_PRIVATE_DATA, DeviceRecoveryPpi, PEI_FAT_PRIVATE_DATA_SIGNATURE)\r
	174	\r
	175	//\r
	176	// Extract INT32 from char array\r
	177	//\r
	178	#define UNPACK_INT32(a) \\r
	179	(INT32) ((((UINT8 ) a)[0] << 0) \| (((UINT8 ) a)[1] << 8) \| (((UINT8 ) a)[2] << 16) \| (((UINT8 ) a)[3] << 24))\r
	180	\r
	181	//\r
	182	// Extract UINT32 from char array\r
	183	//\r
	184	#define UNPACK_UINT32(a) \\r
	185	(UINT32) ((((UINT8 ) a)[0] << 0) \| (((UINT8 ) a)[1] << 8) \| (((UINT8 ) a)[2] << 16) \| (((UINT8 ) a)[3] << 24))\r
	186	\r
	187	\r
	188	//\r
	189	// API functions\r
	190	//\r
	191	\r
	192	/**\r
	193	Finds the recovery file on a FAT volume.\r
	194	This function finds the the recovery file named FileName on a specified FAT volume and returns\r
	195	its FileHandle pointer.\r
	196	\r
e38f26a2 LG	197	@param PrivateData Global memory map for accessing global\r
	198	variables.\r
	199	@param VolumeIndex The index of the volume.\r
	200	@param FileName The recovery file name to find.\r
	201	@param Handle The output file handle.\r
2f4dfa84	202	\r
e38f26a2 LG	203	@retval EFI_DEVICE_ERROR Some error occured when operating the FAT\r
	204	volume.\r
	205	@retval EFI_NOT_FOUND The recovery file was not found.\r
	206	@retval EFI_SUCCESS The recovery file was successfully found on the\r
2f4dfa84 JJ	207	FAT volume.\r
	208	\r
	209	**/\r
	210	EFI_STATUS\r
	211	FindRecoveryFile (\r
	212	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	213	IN UINTN VolumeIndex,\r
	214	IN CHAR16 *FileName,\r
	215	OUT PEI_FILE_HANDLE *Handle\r
	216	);\r
	217	\r
	218	\r
	219	/**\r
	220	Returns the number of DXE capsules residing on the device.\r
	221	This function, by whatever mechanism, searches for DXE capsules from the associated device and\r
	222	returns the number and maximum size in bytes of the capsules discovered.Entry 1 is assumed to be\r
	223	the highest load priority and entry N is assumed to be the lowest priority.\r
	224	\r
e38f26a2 LG	225	@param PeiServices General-purpose services that are available to\r
	226	every PEIM.\r
	227	@param This Indicates the\r
	228	EFI_PEI_DEVICE_RECOVERY_MODULE_PPI instance.\r
	229	@param NumberRecoveryCapsules Pointer to a caller-allocated UINTN.On output,\r
	230	*NumberRecoveryCapsules contains the number of\r
	231	recovery capsule images available for retrieval\r
	232	from this PEIM instance.\r
2f4dfa84 JJ	233	\r
	234	@retval EFI_SUCCESS The function completed successfully.\r
	235	\r
	236	**/\r
	237	EFI_STATUS\r
	238	EFIAPI\r
	239	GetNumberRecoveryCapsules (\r
	240	IN EFI_PEI_SERVICES **PeiServices,\r
	241	IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
	242	OUT UINTN *NumberRecoveryCapsules\r
	243	);\r
	244	\r
	245	\r
	246	/**\r
	247	Returns the size and type of the requested recovery capsule.\r
	248	This function returns the size and type of the capsule specified by CapsuleInstance.\r
	249	\r
e38f26a2 LG	250	@param PeiServices General-purpose services that are available to\r
	251	every PEIM.\r
	252	@param This Indicates the\r
	253	EFI_PEI_DEVICE_RECOVERY_MODULE_PPI instance.\r
	254	@param CapsuleInstance Specifies for which capsule instance to\r
	255	retrieve the information.T his parameter must\r
	256	be between one and the value returned by\r
	257	GetNumberRecoveryCapsules() in\r
	258	NumberRecoveryCapsules.\r
	259	@param Size A pointer to a caller-allocated UINTN in which\r
	260	the size of the requested recovery module is\r
	261	returned.\r
	262	@param CapsuleType A pointer to a caller-allocated EFI_GUID in\r
	263	which the type of the requested recovery\r
	264	capsule is returned.T he semantic meaning of\r
	265	the value returned is defined by the\r
	266	implementation.\r
	267	\r
	268	@retval EFI_SUCCESS The capsule type and size were retrieved.\r
	269	@retval EFI_INVALID_PARAMETER The input CapsuleInstance does not match any\r
2f4dfa84 JJ	270	discovered recovery capsule.\r
	271	\r
	272	**/\r
	273	EFI_STATUS\r
	274	EFIAPI\r
	275	GetRecoveryCapsuleInfo (\r
	276	IN EFI_PEI_SERVICES **PeiServices,\r
	277	IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
	278	IN UINTN CapsuleInstance,\r
	279	OUT UINTN *Size,\r
	280	OUT EFI_GUID *CapsuleType\r
	281	);\r
	282	\r
	283	\r
	284	/**\r
	285	Loads a DXE capsule from some media into memory.\r
	286	\r
	287	This function, by whatever mechanism, retrieves a DXE capsule from some device\r
	288	and loads it into memory. Note that the published interface is device neutral.\r
	289	\r
e38f26a2	290	@param[in] PeiServices General-purpose services that are available\r
2f4dfa84 JJ	291	to every PEIM\r
	292	@param[in] This Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI\r
	293	instance.\r
	294	@param[in] CapsuleInstance Specifies which capsule instance to retrieve.\r
e38f26a2	295	@param[out] Buffer Specifies a caller-allocated buffer in which\r
2f4dfa84 JJ	296	the requested recovery capsule will be returned.\r
	297	\r
	298	@retval EFI_SUCCESS The capsule was loaded correctly.\r
	299	@retval EFI_DEVICE_ERROR A device error occurred.\r
	300	@retval EFI_NOT_FOUND A requested recovery DXE capsule cannot be found.\r
	301	\r
	302	**/\r
	303	EFI_STATUS\r
	304	EFIAPI\r
	305	LoadRecoveryCapsule (\r
	306	IN EFI_PEI_SERVICES **PeiServices,\r
	307	IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
	308	IN UINTN CapsuleInstance,\r
	309	OUT VOID *Buffer\r
	310	);\r
	311	\r
	312	\r
	313	/**\r
	314	This version is different from the version in Unicode collation\r
	315	protocol in that this version strips off trailing blanks.\r
	316	Converts an 8.3 FAT file name using an OEM character set\r
	317	to a Null-terminated Unicode string.\r
	318	Here does not expand DBCS FAT chars.\r
	319	\r
e38f26a2 LG	320	@param FatSize The size of the string Fat in bytes.\r
	321	@param Fat A pointer to a Null-terminated string that contains\r
	322	an 8.3 file name using an OEM character set.\r
	323	@param Str A pointer to a Null-terminated Unicode string. The\r
	324	string must be allocated in advance to hold FatSize\r
2f4dfa84 JJ	325	Unicode characters\r
	326	\r
	327	**/\r
	328	VOID\r
	329	EngFatToStr (\r
	330	IN UINTN FatSize,\r
	331	IN CHAR8 *Fat,\r
	332	OUT CHAR16 *Str\r
	333	);\r
	334	\r
	335	\r
	336	/**\r
	337	Performs a case-insensitive comparison of two Null-terminated Unicode strings.\r
	338	\r
e38f26a2 LG	339	@param PrivateData Global memory map for accessing global variables\r
e38f26a2 LG	340	@param Str1 First string to perform case insensitive comparison.\r
2f4dfa84 JJ	341	@param Str2 Second string to perform case insensitive comparison.\r
	342	\r
	343	**/\r
	344	BOOLEAN\r
	345	EngStriColl (\r
	346	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	347	IN CHAR16 *Str1,\r
	348	IN CHAR16 *Str2\r
	349	);\r
	350	\r
	351	\r
	352	/**\r
	353	Reads a block of data from the block device by calling\r
	354	underlying Block I/O service.\r
	355	\r
e38f26a2 LG	356	@param PrivateData Global memory map for accessing global variables\r
	357	@param BlockDeviceNo The index for the block device number.\r
	358	@param Lba The logic block address to read data from.\r
	359	@param BufferSize The size of data in byte to read.\r
	360	@param Buffer The buffer of the\r
2f4dfa84	361	\r
e38f26a2 LG	362	@retval EFI_DEVICE_ERROR The specified block device number exceeds the maximum\r
	363	device number.\r
	364	@retval EFI_DEVICE_ERROR The maximum address has exceeded the maximum address\r
2f4dfa84 JJ	365	of the block device.\r
	366	\r
	367	**/\r
	368	EFI_STATUS\r
	369	FatReadBlock (\r
	370	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	371	IN UINTN BlockDeviceNo,\r
	372	IN EFI_PEI_LBA Lba,\r
	373	IN UINTN BufferSize,\r
	374	OUT VOID *Buffer\r
	375	);\r
	376	\r
	377	\r
	378	/**\r
	379	Check if there is a valid FAT in the corresponding Block device\r
	380	of the volume and if yes, fill in the relevant fields for the\r
	381	volume structure. Note there should be a valid Block device number\r
	382	already set.\r
	383	\r
e38f26a2 LG	384	@param PrivateData Global memory map for accessing global\r
	385	variables.\r
	386	@param Volume On input, the BlockDeviceNumber field of the\r
	387	Volume should be a valid value. On successful\r
	388	output, all fields except the VolumeNumber\r
	389	field is initialized.\r
2f4dfa84	390	\r
e38f26a2 LG	391	@retval EFI_SUCCESS A FAT is found and the volume structure is\r
	392	initialized.\r
	393	@retval EFI_NOT_FOUND There is no FAT on the corresponding device.\r
2f4dfa84 JJ	394	@retval EFI_DEVICE_ERROR There is something error while accessing device.\r
	395	\r
	396	**/\r
	397	EFI_STATUS\r
	398	FatGetBpbInfo (\r
	399	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	400	IN OUT PEI_FAT_VOLUME *Volume\r
	401	);\r
	402	\r
	403	\r
	404	/**\r
	405	Gets the next cluster in the cluster chain.\r
	406	\r
e38f26a2 LG	407	@param PrivateData Global memory map for accessing global variables\r
	408	@param Volume The volume\r
	409	@param Cluster The cluster\r
	410	@param NextCluster The cluster number of the next cluster\r
2f4dfa84	411	\r
e38f26a2 LG	412	@retval EFI_SUCCESS The address is got\r
e38f26a2 LG	413	@retval EFI_INVALID_PARAMETER ClusterNo exceeds the MaxCluster of the volume.\r
2f4dfa84 JJ	414	@retval EFI_DEVICE_ERROR Read disk error\r
	415	\r
	416	**/\r
	417	EFI_STATUS\r
	418	FatGetNextCluster (\r
	419	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	420	IN PEI_FAT_VOLUME *Volume,\r
	421	IN UINT32 Cluster,\r
	422	OUT UINT32 *NextCluster\r
	423	);\r
	424	\r
	425	\r
	426	/**\r
	427	Disk reading.\r
	428	\r
e38f26a2 LG	429	@param PrivateData the global memory map;\r
	430	@param BlockDeviceNo the block device to read;\r
	431	@param StartingAddress the starting address.\r
	432	@param Size the amount of data to read.\r
	433	@param Buffer the buffer holding the data\r
2f4dfa84 JJ	434	\r
	435	@retval EFI_SUCCESS The function completed successfully.\r
	436	@retval EFI_DEVICE_ERROR Something error.\r
	437	\r
	438	**/\r
	439	EFI_STATUS\r
	440	FatReadDisk (\r
	441	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	442	IN UINTN BlockDeviceNo,\r
	443	IN UINT64 StartingAddress,\r
	444	IN UINTN Size,\r
	445	OUT VOID *Buffer\r
	446	);\r
	447	\r
	448	\r
	449	/**\r
	450	Set a file's CurrentPos and CurrentCluster, then compute StraightReadAmount.\r
	451	\r
e38f26a2 LG	452	@param PrivateData the global memory map\r
	453	@param File the file\r
	454	@param Pos the Position which is offset from the file's\r
	455	CurrentPos\r
2f4dfa84	456	\r
e38f26a2 LG	457	@retval EFI_SUCCESS Success.\r
e38f26a2 LG	458	@retval EFI_INVALID_PARAMETER Pos is beyond file's size.\r
2f4dfa84 JJ	459	@retval EFI_DEVICE_ERROR Something error while accessing media.\r
	460	\r
	461	**/\r
	462	EFI_STATUS\r
	463	FatSetFilePos (\r
	464	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	465	IN PEI_FAT_FILE *File,\r
	466	IN UINT32 Pos\r
	467	);\r
	468	\r
	469	\r
	470	/**\r
	471	Reads file data. Updates the file's CurrentPos.\r
	472	\r
e38f26a2 LG	473	@param PrivateData Global memory map for accessing global variables\r
	474	@param File The file.\r
	475	@param Size The amount of data to read.\r
	476	@param Buffer The buffer storing the data.\r
2f4dfa84	477	\r
e38f26a2 LG	478	@retval EFI_SUCCESS The data is read.\r
e38f26a2 LG	479	@retval EFI_INVALID_PARAMETER File is invalid.\r
2f4dfa84 JJ	480	@retval EFI_DEVICE_ERROR Something error while accessing media.\r
	481	\r
	482	**/\r
	483	EFI_STATUS\r
	484	FatReadFile (\r
	485	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	486	IN PEI_FAT_FILE *File,\r
	487	IN UINTN Size,\r
	488	OUT VOID *Buffer\r
	489	);\r
	490	\r
	491	\r
	492	/**\r
	493	This function reads the next item in the parent directory and\r
	494	initializes the output parameter SubFile (CurrentPos is initialized to 0).\r
	495	The function updates the CurrentPos of the parent dir to after the item read.\r
	496	If no more items were found, the function returns EFI_NOT_FOUND.\r
	497	\r
e38f26a2 LG	498	@param PrivateData Global memory map for accessing global variables\r
	499	@param ParentDir The parent directory.\r
	500	@param SubFile The File structure containing the sub file that\r
	501	is caught.\r
2f4dfa84	502	\r
e38f26a2 LG	503	@retval EFI_SUCCESS The next sub file is obtained.\r
	504	@retval EFI_INVALID_PARAMETER The ParentDir is not a directory.\r
	505	@retval EFI_NOT_FOUND No more sub file exists.\r
2f4dfa84 JJ	506	@retval EFI_DEVICE_ERROR Something error while accessing media.\r
	507	\r
	508	**/\r
	509	EFI_STATUS\r
	510	FatReadNextDirectoryEntry (\r
	511	IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
	512	IN PEI_FAT_FILE *ParentDir,\r
	513	OUT PEI_FAT_FILE *SubFile\r
	514	);\r
	515	\r
	516	\r
	517	/**\r
	518	This function finds partitions (logical devices) in physical block devices.\r
	519	\r
	520	@param PrivateData Global memory map for accessing global variables.\r
	521	\r
	522	**/\r
	523	VOID\r
	524	FatFindPartitions (\r
	525	IN PEI_FAT_PRIVATE_DATA *PrivateData\r
	526	);\r
	527	\r
	528	#endif // _FAT_PEIM_H_\r