/** * Copyright (c) 2011-2018 Bill Greiman * This file is part of the SdFat library for SD memory cards. * * MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #ifndef FatStructs_h #define FatStructs_h /** * \file * \brief FAT file structures */ /* * mostly from Microsoft document fatgen103.doc * http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx */ //------------------------------------------------------------------------------ /** Value for byte 510 of boot block or MBR */ const uint8_t BOOTSIG0 = 0X55; /** Value for byte 511 of boot block or MBR */ const uint8_t BOOTSIG1 = 0XAA; /** Value for bootSignature field int FAT/FAT32 boot sector */ const uint8_t EXTENDED_BOOT_SIG = 0X29; //------------------------------------------------------------------------------ /** * \struct partitionTable * \brief MBR partition table entry * * A partition table entry for a MBR formatted storage device. * The MBR partition table has four entries. */ struct partitionTable { /** * Boot Indicator . Indicates whether the volume is the active * partition. Legal values include: 0X00. Do not use for booting. * 0X80 Active partition. */ uint8_t boot; /** * Head part of Cylinder-head-sector address of the first block in * the partition. Legal values are 0-255. Only used in old PC BIOS. */ uint8_t beginHead; /** * Sector part of Cylinder-head-sector address of the first block in * the partition. Legal values are 1-63. Only used in old PC BIOS. */ unsigned beginSector : 6; /** High bits cylinder for first block in partition. */ unsigned beginCylinderHigh : 2; /** * Combine beginCylinderLow with beginCylinderHigh. Legal values * are 0-1023. Only used in old PC BIOS. */ uint8_t beginCylinderLow; /** * Partition type. See defines that begin with PART_TYPE_ for * some Microsoft partition types. */ uint8_t type; /** * head part of cylinder-head-sector address of the last sector in the * partition. Legal values are 0-255. Only used in old PC BIOS. */ uint8_t endHead; /** * Sector part of cylinder-head-sector address of the last sector in * the partition. Legal values are 1-63. Only used in old PC BIOS. */ unsigned endSector : 6; /** High bits of end cylinder */ unsigned endCylinderHigh : 2; /** * Combine endCylinderLow with endCylinderHigh. Legal values * are 0-1023. Only used in old PC BIOS. */ uint8_t endCylinderLow; /** Logical block address of the first block in the partition. */ uint32_t firstSector; /** Length of the partition, in blocks. */ uint32_t totalSectors; } __attribute__((packed)); /** Type name for partitionTable */ typedef struct partitionTable part_t; //------------------------------------------------------------------------------ /** * \struct masterBootRecord * * \brief Master Boot Record * * The first block of a storage device that is formatted with a MBR. */ struct masterBootRecord { /** Code Area for master boot program. */ uint8_t codeArea[440]; /** Optional Windows NT disk signature. May contain boot code. */ uint32_t diskSignature; /** Usually zero but may be more boot code. */ uint16_t usuallyZero; /** Partition tables. */ part_t part[4]; /** First MBR signature byte. Must be 0X55 */ uint8_t mbrSig0; /** Second MBR signature byte. Must be 0XAA */ uint8_t mbrSig1; } __attribute__((packed)); /** Type name for masterBootRecord */ typedef struct masterBootRecord mbr_t; //------------------------------------------------------------------------------ /** * \struct biosParmBlock * * \brief BIOS parameter block * * The BIOS parameter block describes the physical layout of a FAT volume. */ struct biosParmBlock { /** * Count of bytes per sector. This value may take on only the * following values: 512, 1024, 2048 or 4096 */ uint16_t bytesPerSector; /** * Number of sectors per allocation unit. This value must be a * power of 2 that is greater than 0. The legal values are * 1, 2, 4, 8, 16, 32, 64, and 128. */ uint8_t sectorsPerCluster; /** * Number of sectors before the first FAT. * This value must not be zero. */ uint16_t reservedSectorCount; /** The count of FAT data structures on the volume. This field should * always contain the value 2 for any FAT volume of any type. */ uint8_t fatCount; /** * For FAT12 and FAT16 volumes, this field contains the count of * 32-byte directory entries in the root directory. For FAT32 volumes, * this field must be set to 0. For FAT12 and FAT16 volumes, this * value should always specify a count that when multiplied by 32 * results in a multiple of bytesPerSector. FAT16 volumes should * use the value 512. */ uint16_t rootDirEntryCount; /** * This field is the old 16-bit total count of sectors on the volume. * This count includes the count of all sectors in all four regions * of the volume. This field can be 0; if it is 0, then totalSectors32 * must be nonzero. For FAT32 volumes, this field must be 0. For * FAT12 and FAT16 volumes, this field contains the sector count, and * totalSectors32 is 0 if the total sector count fits * (is less than 0x10000). */ uint16_t totalSectors16; /** * This dates back to the old MS-DOS 1.x media determination and is * no longer usually used for anything. 0xF8 is the standard value * for fixed (nonremovable) media. For removable media, 0xF0 is * frequently used. Legal values are 0xF0 or 0xF8-0xFF. */ uint8_t mediaType; /** * Count of sectors occupied by one FAT on FAT12/FAT16 volumes. * On FAT32 volumes this field must be 0, and sectorsPerFat32 * contains the FAT size count. */ uint16_t sectorsPerFat16; /** Sectors per track for interrupt 0x13. Not used otherwise. */ uint16_t sectorsPerTrtack; /** Number of heads for interrupt 0x13. Not used otherwise. */ uint16_t headCount; /** * Count of hidden sectors preceding the partition that contains this * FAT volume. This field is generally only relevant for media * visible on interrupt 0x13. */ uint32_t hidddenSectors; /** * This field is the new 32-bit total count of sectors on the volume. * This count includes the count of all sectors in all four regions * of the volume. This field can be 0; if it is 0, then * totalSectors16 must be nonzero. */ uint32_t totalSectors32; /** * Count of sectors occupied by one FAT on FAT32 volumes. */ uint32_t sectorsPerFat32; /** * This field is only defined for FAT32 media and does not exist on * FAT12 and FAT16 media. * Bits 0-3 -- Zero-based number of active FAT. * Only valid if mirroring is disabled. * Bits 4-6 -- Reserved. * Bit 7 -- 0 means the FAT is mirrored at runtime into all FATs. * -- 1 means only one FAT is active; it is the one referenced in bits 0-3. * Bits 8-15 -- Reserved. */ uint16_t fat32Flags; /** * FAT32 version. High byte is major revision number. * Low byte is minor revision number. Only 0.0 define. */ uint16_t fat32Version; /** * Cluster number of the first cluster of the root directory for FAT32. * This usually 2 but not required to be 2. */ uint32_t fat32RootCluster; /** * Sector number of FSINFO structure in the reserved area of the * FAT32 volume. Usually 1. */ uint16_t fat32FSInfo; /** * If nonzero, indicates the sector number in the reserved area * of the volume of a copy of the boot record. Usually 6. * No value other than 6 is recommended. */ uint16_t fat32BackBootBlock; /** * Reserved for future expansion. Code that formats FAT32 volumes * should always set all of the bytes of this field to 0. */ uint8_t fat32Reserved[12]; } __attribute__((packed)); /** Type name for biosParmBlock */ typedef struct biosParmBlock bpb_t; //------------------------------------------------------------------------------ /** * \struct fat_boot * * \brief Boot sector for a FAT12/FAT16 volume. * */ struct fat_boot { /** * The first three bytes of the boot sector must be valid, * executable x 86-based CPU instructions. This includes a * jump instruction that skips the next non-executable bytes. */ uint8_t jump[3]; /** * This is typically a string of characters that identifies * the operating system that formatted the volume. */ char oemId[8]; /** * The size of a hardware sector. Valid decimal values for this * field are 512, 1024, 2048, and 4096. For most disks used in * the United States, the value of this field is 512. */ uint16_t bytesPerSector; /** * Number of sectors per allocation unit. This value must be a * power of 2 that is greater than 0. The legal values are * 1, 2, 4, 8, 16, 32, 64, and 128. 128 should be avoided. */ uint8_t sectorsPerCluster; /** * The number of sectors preceding the start of the first FAT, * including the boot sector. The value of this field is always 1. */ uint16_t reservedSectorCount; /** * The number of copies of the FAT on the volume. * The value of this field is always 2. */ uint8_t fatCount; /** * For FAT12 and FAT16 volumes, this field contains the count of * 32-byte directory entries in the root directory. For FAT32 volumes, * this field must be set to 0. For FAT12 and FAT16 volumes, this * value should always specify a count that when multiplied by 32 * results in a multiple of bytesPerSector. FAT16 volumes should * use the value 512. */ uint16_t rootDirEntryCount; /** * This field is the old 16-bit total count of sectors on the volume. * This count includes the count of all sectors in all four regions * of the volume. This field can be 0; if it is 0, then totalSectors32 * must be non-zero. For FAT32 volumes, this field must be 0. For * FAT12 and FAT16 volumes, this field contains the sector count, and * totalSectors32 is 0 if the total sector count fits * (is less than 0x10000). */ uint16_t totalSectors16; /** * This dates back to the old MS-DOS 1.x media determination and is * no longer usually used for anything. 0xF8 is the standard value * for fixed (non-removable) media. For removable media, 0xF0 is * frequently used. Legal values are 0xF0 or 0xF8-0xFF. */ uint8_t mediaType; /** * Count of sectors occupied by one FAT on FAT12/FAT16 volumes. * On FAT32 volumes this field must be 0, and sectorsPerFat32 * contains the FAT size count. */ uint16_t sectorsPerFat16; /** Sectors per track for interrupt 0x13. Not used otherwise. */ uint16_t sectorsPerTrack; /** Number of heads for interrupt 0x13. Not used otherwise. */ uint16_t headCount; /** * Count of hidden sectors preceding the partition that contains this * FAT volume. This field is generally only relevant for media * visible on interrupt 0x13. */ uint32_t hidddenSectors; /** * This field is the new 32-bit total count of sectors on the volume. * This count includes the count of all sectors in all four regions * of the volume. This field can be 0; if it is 0, then * totalSectors16 must be non-zero. */ uint32_t totalSectors32; /** * Related to the BIOS physical drive number. Floppy drives are * identified as 0x00 and physical hard disks are identified as * 0x80, regardless of the number of physical disk drives. * Typically, this value is set prior to issuing an INT 13h BIOS * call to specify the device to access. The value is only * relevant if the device is a boot device. */ uint8_t driveNumber; /** used by Windows NT - should be zero for FAT */ uint8_t reserved1; /** 0X29 if next three fields are valid */ uint8_t bootSignature; /** * A random serial number created when formatting a disk, * which helps to distinguish between disks. * Usually generated by combining date and time. */ uint32_t volumeSerialNumber; /** * A field once used to store the volume label. The volume label * is now stored as a special file in the root directory. */ char volumeLabel[11]; /** * A field with a value of either FAT, FAT12 or FAT16, * depending on the disk format. */ char fileSystemType[8]; /** X86 boot code */ uint8_t bootCode[448]; /** must be 0X55 */ uint8_t bootSectorSig0; /** must be 0XAA */ uint8_t bootSectorSig1; } __attribute__((packed)); /** Type name for FAT Boot Sector */ typedef struct fat_boot fat_boot_t; //------------------------------------------------------------------------------ /** * \struct fat32_boot * * \brief Boot sector for a FAT32 volume. * */ struct fat32_boot { /** * The first three bytes of the boot sector must be valid, * executable x 86-based CPU instructions. This includes a * jump instruction that skips the next non-executable bytes. */ uint8_t jump[3]; /** * This is typically a string of characters that identifies * the operating system that formatted the volume. */ char oemId[8]; /** * The size of a hardware sector. Valid decimal values for this * field are 512, 1024, 2048, and 4096. For most disks used in * the United States, the value of this field is 512. */ uint16_t bytesPerSector; /** * Number of sectors per allocation unit. This value must be a * power of 2 that is greater than 0. The legal values are * 1, 2, 4, 8, 16, 32, 64, and 128. 128 should be avoided. */ uint8_t sectorsPerCluster; /** * The number of sectors preceding the start of the first FAT, * including the boot sector. Must not be zero */ uint16_t reservedSectorCount; /** * The number of copies of the FAT on the volume. * The value of this field is always 2. */ uint8_t fatCount; /** * FAT12/FAT16 only. For FAT32 volumes, this field must be set to 0. */ uint16_t rootDirEntryCount; /** * For FAT32 volumes, this field must be 0. */ uint16_t totalSectors16; /** * This dates back to the old MS-DOS 1.x media determination and is * no longer usually used for anything. 0xF8 is the standard value * for fixed (non-removable) media. For removable media, 0xF0 is * frequently used. Legal values are 0xF0 or 0xF8-0xFF. */ uint8_t mediaType; /** * On FAT32 volumes this field must be 0, and sectorsPerFat32 * contains the FAT size count. */ uint16_t sectorsPerFat16; /** Sectors per track for interrupt 0x13. Not used otherwise. */ uint16_t sectorsPerTrack; /** Number of heads for interrupt 0x13. Not used otherwise. */ uint16_t headCount; /** * Count of hidden sectors preceding the partition that contains this * FAT volume. This field is generally only relevant for media * visible on interrupt 0x13. */ uint32_t hidddenSectors; /** * Contains the total number of sectors in the FAT32 volume. */ uint32_t totalSectors32; /** * Count of sectors occupied by one FAT on FAT32 volumes. */ uint32_t sectorsPerFat32; /** * This field is only defined for FAT32 media and does not exist on * FAT12 and FAT16 media. * Bits 0-3 -- Zero-based number of active FAT. * Only valid if mirroring is disabled. * Bits 4-6 -- Reserved. * Bit 7 -- 0 means the FAT is mirrored at runtime into all FATs. * -- 1 means only one FAT is active; it is the one referenced * in bits 0-3. * Bits 8-15 -- Reserved. */ uint16_t fat32Flags; /** * FAT32 version. High byte is major revision number. * Low byte is minor revision number. Only 0.0 define. */ uint16_t fat32Version; /** * Cluster number of the first cluster of the root directory for FAT32. * This usually 2 but not required to be 2. */ uint32_t fat32RootCluster; /** * Sector number of FSINFO structure in the reserved area of the * FAT32 volume. Usually 1. */ uint16_t fat32FSInfo; /** * If non-zero, indicates the sector number in the reserved area * of the volume of a copy of the boot record. Usually 6. * No value other than 6 is recommended. */ uint16_t fat32BackBootBlock; /** * Reserved for future expansion. Code that formats FAT32 volumes * should always set all of the bytes of this field to 0. */ uint8_t fat32Reserved[12]; /** * Related to the BIOS physical drive number. Floppy drives are * identified as 0x00 and physical hard disks are identified as * 0x80, regardless of the number of physical disk drives. * Typically, this value is set prior to issuing an INT 13h BIOS * call to specify the device to access. The value is only * relevant if the device is a boot device. */ uint8_t driveNumber; /** used by Windows NT - should be zero for FAT */ uint8_t reserved1; /** 0X29 if next three fields are valid */ uint8_t bootSignature; /** * A random serial number created when formatting a disk, * which helps to distinguish between disks. * Usually generated by combining date and time. */ uint32_t volumeSerialNumber; /** * A field once used to store the volume label. The volume label * is now stored as a special file in the root directory. */ char volumeLabel[11]; /** * A text field with a value of FAT32. */ char fileSystemType[8]; /** X86 boot code */ uint8_t bootCode[420]; /** must be 0X55 */ uint8_t bootSectorSig0; /** must be 0XAA */ uint8_t bootSectorSig1; } __attribute__((packed)); /** Type name for FAT32 Boot Sector */ typedef struct fat32_boot fat32_boot_t; //------------------------------------------------------------------------------ /** Lead signature for a FSINFO sector */ const uint32_t FSINFO_LEAD_SIG = 0x41615252; /** Struct signature for a FSINFO sector */ const uint32_t FSINFO_STRUCT_SIG = 0x61417272; /** * \struct fat32_fsinfo * * \brief FSINFO sector for a FAT32 volume. * */ struct fat32_fsinfo { /** must be 0X52, 0X52, 0X61, 0X41 */ uint32_t leadSignature; /** must be zero */ uint8_t reserved1[480]; /** must be 0X72, 0X72, 0X41, 0X61 */ uint32_t structSignature; /** * Contains the last known free cluster count on the volume. * If the value is 0xFFFFFFFF, then the free count is unknown * and must be computed. Any other value can be used, but is * not necessarily correct. It should be range checked at least * to make sure it is <= volume cluster count. */ uint32_t freeCount; /** * This is a hint for the FAT driver. It indicates the cluster * number at which the driver should start looking for free clusters. * If the value is 0xFFFFFFFF, then there is no hint and the driver * should start looking at cluster 2. */ uint32_t nextFree; /** must be zero */ uint8_t reserved2[12]; /** must be 0X00, 0X00, 0X55, 0XAA */ uint8_t tailSignature[4]; } __attribute__((packed)); /** Type name for FAT32 FSINFO Sector */ typedef struct fat32_fsinfo fat32_fsinfo_t; //------------------------------------------------------------------------------ // End Of Chain values for FAT entries /** FAT12 end of chain value used by Microsoft. */ const uint16_t FAT12EOC = 0XFFF; /** Minimum value for FAT12 EOC. Use to test for EOC. */ const uint16_t FAT12EOC_MIN = 0XFF8; /** FAT16 end of chain value used by Microsoft. */ const uint16_t FAT16EOC = 0XFFFF; /** Minimum value for FAT16 EOC. Use to test for EOC. */ const uint16_t FAT16EOC_MIN = 0XFFF8; /** FAT32 end of chain value used by Microsoft. */ const uint32_t FAT32EOC = 0X0FFFFFFF; /** Minimum value for FAT32 EOC. Use to test for EOC. */ const uint32_t FAT32EOC_MIN = 0X0FFFFFF8; /** Mask a for FAT32 entry. Entries are 28 bits. */ const uint32_t FAT32MASK = 0X0FFFFFFF; //------------------------------------------------------------------------------ /** * \struct directoryEntry * \brief FAT short directory entry * * Short means short 8.3 name, not the entry size. * * Date Format. A FAT directory entry date stamp is a 16-bit field that is * basically a date relative to the MS-DOS epoch of 01/01/1980. Here is the * format (bit 0 is the LSB of the 16-bit word, bit 15 is the MSB of the * 16-bit word): * * Bits 9-15: Count of years from 1980, valid value range 0-127 * inclusive (1980-2107). * * Bits 5-8: Month of year, 1 = January, valid value range 1-12 inclusive. * * Bits 0-4: Day of month, valid value range 1-31 inclusive. * * Time Format. A FAT directory entry time stamp is a 16-bit field that has * a granularity of 2 seconds. Here is the format (bit 0 is the LSB of the * 16-bit word, bit 15 is the MSB of the 16-bit word). * * Bits 11-15: Hours, valid value range 0-23 inclusive. * * Bits 5-10: Minutes, valid value range 0-59 inclusive. * * Bits 0-4: 2-second count, valid value range 0-29 inclusive (0 - 58 seconds). * * The valid time range is from Midnight 00:00:00 to 23:59:58. */ struct directoryEntry { /** Short 8.3 name. * * The first eight bytes contain the file name with blank fill. * The last three bytes contain the file extension with blank fill. */ uint8_t name[11]; /** Entry attributes. * * The upper two bits of the attribute byte are reserved and should * always be set to 0 when a file is created and never modified or * looked at after that. See defines that begin with DIR_ATT_. */ uint8_t attributes; /** * Reserved for use by Windows NT. Set value to 0 when a file is * created and never modify or look at it after that. */ uint8_t reservedNT; /** * The granularity of the seconds part of creationTime is 2 seconds * so this field is a count of tenths of a second and its valid * value range is 0-199 inclusive. (WHG note - seems to be hundredths) */ uint8_t creationTimeTenths; /** Time file was created. */ uint16_t creationTime; /** Date file was created. */ uint16_t creationDate; /** * Last access date. Note that there is no last access time, only * a date. This is the date of last read or write. In the case of * a write, this should be set to the same date as lastWriteDate. */ uint16_t lastAccessDate; /** * High word of this entry's first cluster number (always 0 for a * FAT12 or FAT16 volume). */ uint16_t firstClusterHigh; /** Time of last write. File creation is considered a write. */ uint16_t lastWriteTime; /** Date of last write. File creation is considered a write. */ uint16_t lastWriteDate; /** Low word of this entry's first cluster number. */ uint16_t firstClusterLow; /** 32-bit unsigned holding this file's size in bytes. */ uint32_t fileSize; } __attribute__((packed)); /** Type name for directoryEntry */ typedef struct directoryEntry dir_t; //------------------------------------------------------------------------------ // Definitions for directory entries // /** escape for name[0] = 0XE5 */ const uint8_t DIR_NAME_0XE5 = 0X05; /** name[0] value for entry that is free after being "deleted" */ const uint8_t DIR_NAME_DELETED = 0XE5; /** name[0] value for entry that is free and no allocated entries follow */ const uint8_t DIR_NAME_FREE = 0X00; /** file is read-only */ const uint8_t DIR_ATT_READ_ONLY = 0X01; /** File should e hidden in directory listings */ const uint8_t DIR_ATT_HIDDEN = 0X02; /** Entry is for a system file */ const uint8_t DIR_ATT_SYSTEM = 0X04; /** Directory entry contains the volume label */ const uint8_t DIR_ATT_VOLUME_ID = 0X08; /** Entry is for a directory */ const uint8_t DIR_ATT_DIRECTORY = 0X10; /** Old DOS archive bit for backup support */ const uint8_t DIR_ATT_ARCHIVE = 0X20; /** Test value for long name entry. Test is (d->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME. */ const uint8_t DIR_ATT_LONG_NAME = 0X0F; /** Test mask for long name entry */ const uint8_t DIR_ATT_LONG_NAME_MASK = 0X3F; /** defined attribute bits */ const uint8_t DIR_ATT_DEFINED_BITS = 0X3F; /** Mask for file/subdirectory tests */ const uint8_t DIR_ATT_FILE_TYPE_MASK = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY); /** Filename base-name is all lower case */ const uint8_t DIR_NT_LC_BASE = 0X08; /** Filename extension is all lower case.*/ const uint8_t DIR_NT_LC_EXT = 0X10; /** Directory entry is for a file * \param[in] dir Pointer to a directory entry. * * \return true if the entry is for a normal file else false. */ static inline uint8_t DIR_IS_FILE(const dir_t* dir) { return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == 0; } /** Directory entry is for a file or subdirectory * \param[in] dir Pointer to a directory entry. * * \return true if the entry is for a normal file or subdirectory else false. */ static inline uint8_t DIR_IS_FILE_OR_SUBDIR(const dir_t* dir) { return (dir->attributes & DIR_ATT_VOLUME_ID) == 0; } /** Directory entry is part of a long name * \param[in] dir Pointer to a directory entry. * * \return true if the entry is for part of a long name else false. */ static inline uint8_t DIR_IS_LONG_NAME(const dir_t* dir) { return dir->attributes == DIR_ATT_LONG_NAME; } /** Directory entry is hidden * \param[in] dir Pointer to a directory entry. * * \return true if the entry is hidden else false. */ static inline uint8_t DIR_IS_HIDDEN(const dir_t* dir) { return dir->attributes & DIR_ATT_HIDDEN; } /** Directory entry is for a subdirectory * \param[in] dir Pointer to a directory entry. * * \return true if the entry is for a subdirectory else false. */ static inline uint8_t DIR_IS_SUBDIR(const dir_t* dir) { return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == DIR_ATT_DIRECTORY; } /** Directory entry is system type * \param[in] dir Pointer to a directory entry. * * \return true if the entry is system else false. */ static inline uint8_t DIR_IS_SYSTEM(const dir_t* dir) { return dir->attributes & DIR_ATT_SYSTEM; } /** date field for FAT directory entry * \param[in] year [1980,2107] * \param[in] month [1,12] * \param[in] day [1,31] * * \return Packed date for dir_t entry. */ static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) { return (year - 1980) << 9 | month << 5 | day; } /** year part of FAT directory date field * \param[in] fatDate Date in packed dir format. * * \return Extracted year [1980,2107] */ static inline uint16_t FAT_YEAR(uint16_t fatDate) { return 1980 + (fatDate >> 9); } /** month part of FAT directory date field * \param[in] fatDate Date in packed dir format. * * \return Extracted month [1,12] */ static inline uint8_t FAT_MONTH(uint16_t fatDate) { return (fatDate >> 5) & 0XF; } /** day part of FAT directory date field * \param[in] fatDate Date in packed dir format. * * \return Extracted day [1,31] */ static inline uint8_t FAT_DAY(uint16_t fatDate) { return fatDate & 0X1F; } /** time field for FAT directory entry * \param[in] hour [0,23] * \param[in] minute [0,59] * \param[in] second [0,59] * * \return Packed time for dir_t entry. */ static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) { return hour << 11 | minute << 5 | second >> 1; } /** hour part of FAT directory time field * \param[in] fatTime Time in packed dir format. * * \return Extracted hour [0,23] */ static inline uint8_t FAT_HOUR(uint16_t fatTime) { return fatTime >> 11; } /** minute part of FAT directory time field * \param[in] fatTime Time in packed dir format. * * \return Extracted minute [0,59] */ static inline uint8_t FAT_MINUTE(uint16_t fatTime) { return (fatTime >> 5) & 0X3F; } /** second part of FAT directory time field * \note second/2 is stored in packed time. * * \param[in] fatTime Time in packed dir format. * * \return Extracted second [0,58] */ static inline uint8_t FAT_SECOND(uint16_t fatTime) { return 2*(fatTime & 0X1F); } /** Default date for file timestamps is 1 Jan 2000 */ const uint16_t FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1; /** Default time for file timestamp is 1 am */ const uint16_t FAT_DEFAULT_TIME = (1 << 11); //------------------------------------------------------------------------------ /** Dimension of first name field in long directory entry */ const uint8_t LDIR_NAME1_DIM = 5; /** Dimension of first name field in long directory entry */ const uint8_t LDIR_NAME2_DIM = 6; /** Dimension of first name field in long directory entry */ const uint8_t LDIR_NAME3_DIM = 2; /** * \struct longDirectoryEntry * \brief FAT long directory entry */ struct longDirectoryEntry { /** * The order of this entry in the sequence of long dir entries * associated with the short dir entry at the end of the long dir set. * * If masked with 0X40 (LAST_LONG_ENTRY), this indicates the * entry is the last long dir entry in a set of long dir entries. * All valid sets of long dir entries must begin with an entry having * this mask. */ uint8_t ord; /** Characters 1-5 of the long-name sub-component in this entry. */ uint16_t name1[LDIR_NAME1_DIM]; /** Attributes - must be ATTR_LONG_NAME */ uint8_t attr; /** * If zero, indicates a directory entry that is a sub-component of a * long name. NOTE: Other values reserved for future extensions. * * Non-zero implies other directory entry types. */ uint8_t type; /** * Checksum of name in the short dir entry at the end of the * long dir set. */ uint8_t chksum; /** Characters 6-11 of the long-name sub-component in this entry. */ uint16_t name2[LDIR_NAME2_DIM]; /** Must be ZERO. This is an artifact of the FAT "first cluster" */ uint16_t mustBeZero; /** Characters 12 and 13 of the long-name sub-component in this entry. */ uint16_t name3[LDIR_NAME3_DIM]; } __attribute__((packed)); /** Type name for longDirectoryEntry */ typedef struct longDirectoryEntry ldir_t; /** * Ord mast that indicates the entry is the last long dir entry in a * set of long dir entries. All valid sets of long dir entries must * begin with an entry having this mask. */ const uint8_t LDIR_ORD_LAST_LONG_ENTRY = 0X40; #endif // FatStructs_h