Blame | Last modification | View Log | RSS feed
/*** Marlin 3D Printer Firmware* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]** Based on Sprinter and grbl.* Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm** This program is free software: you can redistribute it and/or modify* it under the terms of the GNU General Public License as published by* the Free Software Foundation, either version 3 of the License, or* (at your option) any later version.** This program is distributed in the hope that it will be useful,* but WITHOUT ANY WARRANTY; without even the implied warranty of* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the* GNU General Public License for more details.** You should have received a copy of the GNU General Public License* along with this program. If not, see <http://www.gnu.org/licenses/>.**//*** \file* \brief FAT file structures*//*** Arduino SdFat Library* Copyright (C) 2009 by William Greiman** This file is part of the Arduino Sd2Card Library*/#ifndef SDFATSTRUCTS_H#define SDFATSTRUCTS_H#define PACKED __attribute__((__packed__))/*** mostly from Microsoft document fatgen103.doc* http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx*/uint8_t const BOOTSIG0 = 0x55, // Value for byte 510 of boot block or MBRBOOTSIG1 = 0xAA, // Value for byte 511 of boot block or MBREXTENDED_BOOT_SIG = 0x29; // Value for bootSignature field int FAT/FAT32 boot sector/*** \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;uint32_t firstSector; // Logical block address of the first block in the partition.uint32_t totalSectors; // Length of the partition, in blocks.} PACKED;typedef struct partitionTable part_t; // Type name for partitionTable/*** \struct masterBootRecord** \brief Master Boot Record** The first block of a storage device that is formatted with a MBR.*/struct masterBootRecord {uint8_t codeArea[440]; // Code Area for master boot program.uint32_t diskSignature; // Optional Windows NT disk signature. May contain boot code.uint16_t usuallyZero; // Usually zero but may be more boot code.part_t part[4]; // Partition tables.uint8_t mbrSig0; // First MBR signature byte. Must be 0x55uint8_t mbrSig1; // Second MBR signature byte. Must be 0xAA} PACKED;/** Type name for masterBootRecord */typedef struct masterBootRecord mbr_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 nonexecutable 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 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;uint16_t sectorsPerTrack; // Sectors per track for interrupt 0x13. Not used otherwise.uint16_t headCount; // Number of heads for interrupt 0x13. Not used otherwise./*** 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;/*** 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;uint8_t reserved1; // used by Windows NT - should be zero for FATuint8_t bootSignature; // 0x29 if next three fields are valid/*** 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];uint8_t bootCode[448]; // X86 boot codeuint8_t bootSectorSig0; // must be 0x55uint8_t bootSectorSig1; // must be 0xAA} PACKED;typedef struct fat_boot fat_boot_t; // Type name for FAT Boot Sector/*** \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 nonexecutable 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 (nonremovable) 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;uint16_t sectorsPerTrack; // Sectors per track for interrupt 0x13. Not used otherwise.uint16_t headCount; // Number of heads for interrupt 0x13. Not used otherwise./*** 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 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];/*** 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;uint8_t reserved1; // Used by Windows NT - should be zero for FATuint8_t bootSignature; // 0x29 if next three fields are valid/*** 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];uint8_t bootCode[420]; // X86 boot codeuint8_t bootSectorSig0; // must be 0x55uint8_t bootSectorSig1; // must be 0xAA} PACKED;typedef struct fat32_boot fat32_boot_t; // Type name for FAT32 Boot Sectoruint32_t const FSINFO_LEAD_SIG = 0x41615252, // 'AaRR' Lead signature for a FSINFO sectorFSINFO_STRUCT_SIG = 0x61417272; // 'aArr' Struct signature for a FSINFO sector/*** \struct fat32_fsinfo** \brief FSINFO sector for a FAT32 volume.**/struct fat32_fsinfo {uint32_t leadSignature; // must be 0x52, 0x52, 0x61, 0x41 'RRaA'uint8_t reserved1[480]; // must be zerouint32_t structSignature; // must be 0x72, 0x72, 0x41, 0x61 'rrAa'/*** 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;uint8_t reserved2[12]; // must be zerouint8_t tailSignature[4]; // must be 0x00, 0x00, 0x55, 0xAA} PACKED;typedef struct fat32_fsinfo fat32_fsinfo_t; // Type name for FAT32 FSINFO Sector// End Of Chain values for FAT entriesuint16_t const FAT12EOC = 0xFFF, // FAT12 end of chain value used by Microsoft.FAT12EOC_MIN = 0xFF8, // Minimum value for FAT12 EOC. Use to test for EOC.FAT16EOC = 0xFFFF, // FAT16 end of chain value used by Microsoft.FAT16EOC_MIN = 0xFFF8; // Minimum value for FAT16 EOC. Use to test for EOC.uint32_t const FAT32EOC = 0x0FFFFFFF, // FAT32 end of chain value used by Microsoft.FAT32EOC_MIN = 0x0FFFFFF8, // Minimum value for FAT32 EOC. Use to test for EOC.FAT32MASK = 0x0FFFFFFF; // Mask a for FAT32 entry. Entries are 28 bits./*** \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 it's valid* value range is 0-199 inclusive. (WHG note - seems to be hundredths)*/uint8_t creationTimeTenths;uint16_t creationTime; // Time file was created.uint16_t creationDate; // Date file was created./*** 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;uint16_t lastWriteTime; // Time of last write. File creation is considered a write.uint16_t lastWriteDate; // Date of last write. File creation is considered a write.uint16_t firstClusterLow; // Low word of this entry's first cluster number.uint32_t fileSize; // 32-bit unsigned holding this file's size in bytes.} PACKED;/*** \struct directoryVFATEntry* \brief VFAT long filename directory entry** directoryVFATEntries are found in the same list as normal directoryEntry.* But have the attribute field set to DIR_ATT_LONG_NAME.** Long filenames are saved in multiple directoryVFATEntries.* Each entry containing 13 UTF-16 characters.*/struct directoryVFATEntry {/*** Sequence number. Consists of 2 parts:* bit 6: indicates first long filename block for the next file* bit 0-4: the position of this long filename block (first block is 1)*/uint8_t sequenceNumber;uint16_t name1[5]; // First set of UTF-16 charactersuint8_t attributes; // attributes (at the same location as in directoryEntry), always 0x0Fuint8_t reservedNT; // Reserved for use by Windows NT. Always 0.uint8_t checksum; // Checksum of the short 8.3 filename, can be used to checked if the file system as modified by a not-long-filename aware implementation.uint16_t name2[6]; // Second set of UTF-16 charactersuint16_t firstClusterLow; // firstClusterLow is always zero for longFilenamesuint16_t name3[2]; // Third set of UTF-16 characters} PACKED;// Definitions for directory entries//typedef struct directoryEntry dir_t; // Type name for directoryEntrytypedef struct directoryVFATEntry vfat_t; // Type name for directoryVFATEntryuint8_t const DIR_NAME_0xE5 = 0x05, // escape for name[0] = 0xE5DIR_NAME_DELETED = 0xE5, // name[0] value for entry that is free after being "deleted"DIR_NAME_FREE = 0x00, // name[0] value for entry that is free and no allocated entries followDIR_ATT_READ_ONLY = 0x01, // file is read-onlyDIR_ATT_HIDDEN = 0x02, // File should hidden in directory listingsDIR_ATT_SYSTEM = 0x04, // Entry is for a system fileDIR_ATT_VOLUME_ID = 0x08, // Directory entry contains the volume labelDIR_ATT_DIRECTORY = 0x10, // Entry is for a directoryDIR_ATT_ARCHIVE = 0x20, // Old DOS archive bit for backup supportDIR_ATT_LONG_NAME = 0x0F, // Test value for long name entry. Test is (d->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME.DIR_ATT_LONG_NAME_MASK = 0x3F, // Test mask for long name entryDIR_ATT_DEFINED_BITS = 0x3F; // defined attribute bits/*** 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_MASK) == DIR_ATT_LONG_NAME;}/** Mask for file/subdirectory tests */uint8_t const DIR_ATT_FILE_TYPE_MASK = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY);/*** 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 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 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;}#endif // SDFATSTRUCTS_H