FatPkg: Apply uncrustify changes

[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
SPDX-License-Identifier: BSD-2-Clause-Patent\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_MEMORY_PAGE_SIZE  0x1000\r
\r
//\r
// Data Structures\r
//\r
//\r
// The block device\r
//\r
typedef struct {\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
  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
} PEI_FAT_VOLUME;\r
\r
//\r
// File instance\r
//\r
typedef struct {\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
} PEI_FAT_FILE;\r
\r
//\r
// Cache Buffer\r
//\r
typedef struct {\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
} 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
  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
} 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
// API functions\r
//\r
\r
/**\r
  Finds the recovery file on a FAT volume.\r
  This function finds 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 occurred 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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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