FsDefs.hpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#ifndef FS_DEFS_HPP_
#define FS_DEFS_HPP_

#include <stdint.h>
#include <stddef.h>

class FsDefs {
    friend class Fs;
    friend class FsFile;
    friend class FsDir;
    friend class FsPartition;
    friend class FsDrive;

public:
    const static size_t MAX_LFN_CHARS = 255;

    typedef enum {
        RES_SUCCESS = 0x00,
        RES_EOF = 0x01,
        RES_DISK_ERROR = 0x02,
        RES_NOT_FORMATTED = 0x03,
        RES_OUT_OF_MEMORY = 0x04,
        RES_INVALID_PATH = 0x05,
        RES_INVALID_PARTITION = 0x06,
        RES_ENTRY_NOT_FOUND = 0x07,
        RES_FILE_ALREADY_OPEN = 0x08,
        RES_DENIED = 0x09,
        RES_DISK_FULL = 0x0A,
        RES_ENTRY_NOT_OPEN = 0x0B,
        RES_FOLDER_NOT_EMPTY = 0x0C,
        RES_NOT_IMPLEMENTED = 0x0D,
        RES_DRIVE_ID_INVALID = 0x0E,
        RES_NO_MORE_SFN_AVAILABLE = 0x0F,
    } RESULT;

    static const char* getResultString(RESULT result);

    const static size_t SECTOR_BYTES = 512;
    const static size_t SECTOR_DWORDS = 512 / 4;
    const static size_t DIRECTORIES_TABLES_PER_SECTOR = 16;
    const static size_t MAX_LFN_LENGTH = 255;
    const static uint32_t FAT_FREE_CLUSTER = 0;
    const static uint32_t FAT_LAST_CLUSTER = 0xFFFFFFFF;
    const static uint32_t FAT_MAX_CLUSTER_VALUE = 0xFFFFFFF6;
    const static uint8_t ENTRY_LAST = 0;
    const static uint8_t ENTRY_UNUSED = 0xE5;

private:
    typedef enum
        :uint8_t {
            PT_UNUSED = 0x00,
        PT_FAT12 = 0x01,
        PT_FAT16 = 0x04,
        PT_EXTENDED_CHS = 0x05,
        PT_FAT16B = 0x06,
        PT_NTFS = 0x07,
        PT_FAT32 = 0x0B,
        PT_FAT32X = 0x0C,
        PT_FAT16X = 0x0E,
        PT_EXTENDED_LBA = 0x0F,
        PT_PARTITION_EISA = 0x12,
        PT_DYNAMIC_DISK_VOLUME = 0x42,
        PT_LEGACY_FAT16 = 0x86,
        PT_LEGACY_NTFS = 0x87,
        PT_LEGACY_FAT32 = 0x8B,
        PT_LEGACY_PARTITION_EISA = 0x8C,
    } PARTITION_TYPE;

    typedef struct {
        uint8_t bootFlag;
        uint8_t chsBegin[3];
        PARTITION_TYPE partitionType;
        uint8_t chsEnd[3];
        uint32_t lbaBegin;
        uint32_t numberOfSectors;
    }__attribute__((packed)) PARTITION_ENTRY;

    typedef struct {
        uint8_t jmpBoot[3];
        uint8_t oemName[8];
        uint16_t bytsPerSec;
        uint8_t secPerClus;
        uint16_t rsvdSecCnt;
        uint8_t numFats;
        uint16_t rootEntCnt;
        uint16_t totSec16;
        uint8_t media;
        uint16_t fatSz16;
        uint16_t secPerTrk;
        uint16_t numHeads;
        uint32_t hiddSec;
        uint32_t totSec32;
        union {
            struct {
                uint8_t drvNum;
                uint8_t reserved1;
                uint8_t bootSig;
                uint8_t volId[4];
                uint8_t volLab[11];
                uint8_t filSysType[8];
                uint8_t reserved2[448];
                uint16_t checkAA55;
            } fat16;
            struct {
                uint32_t fatSz32;
                uint16_t extFlags;
                uint16_t fsVer;
                uint32_t rootClus;
                uint16_t fsInfo;
                uint16_t bkBootSec;
                uint8_t reserved1[12];
                uint8_t drvNum;
                uint8_t reserved2;
                uint8_t bootSig;
                uint8_t volId[4];
                uint8_t volLab[11];
                uint8_t filSysType[8];
                uint8_t reserved3[420];
                uint16_t checkAA55;
            } fat32;
        } type;
    }__attribute__((packed)) BOOT_SECTOR;

    typedef struct {
        uint32_t leadSig; //0x41615252
        uint8_t reserverd1[480];
        uint32_t structSig; //0x61417272
        uint32_t freeCount;
        uint32_t nextFree;
        uint8_t reserved2[14];
        uint16_t checkAA55; //0xAA55
    }__attribute__((packed)) FS_INFO;

    typedef union {
        struct {
            uint16_t seconds :5; //2-seconds count
            uint16_t minutes :6;
            uint16_t hours :5;
        } bits;
        uint16_t value;
    } TIME;

    typedef union {
        struct {
            uint16_t day :5;
            uint16_t month :4;
            uint16_t year :7;
        } bits;
        uint16_t value;
    } DATE;

    typedef union {
        struct {
            uint8_t readOnly :1;
            uint8_t hidden :1;
            uint8_t system :1;
            uint8_t volumeId :1;
            uint8_t directory :1;
            uint8_t archive :1;
            uint8_t zero2 :1;
            uint8_t zero1 :1;
        } bits;
        uint8_t value;
    } ATTRIBUTES;

    typedef struct {
        char name[8];
        char ext[3];
        ATTRIBUTES attributes;
        uint8_t reserved;
        uint8_t createTimeMs;
        TIME createTime;
        DATE createDate;
        DATE lastAccess;
        uint16_t firstClusterHi;
        TIME lastModifiedTime;
        DATE lastModifiedDate;
        uint16_t firstClusterLo;
        uint32_t fileSize;
    }__attribute__((packed)) SHORT_DIRECTORY_ENTRY;

    typedef struct {
        uint8_t order;
        uint8_t name1[10];
        ATTRIBUTES attributes;
        uint8_t type;
        uint8_t checksum;
        uint8_t name2[12];
        uint16_t firstCluster;
        uint8_t name3[4];
    }__attribute__((packed)) LONG_DIRECTORY_ENTRY;

    const static size_t LFN_MAX_CHARS_PER_ENTRY = 13;

    typedef union {
        SHORT_DIRECTORY_ENTRY shortEntry;
        LONG_DIRECTORY_ENTRY longEntry;
    } DIRECTORY_ENTRY;

    typedef struct {
        uint8_t boot[446];
        PARTITION_ENTRY partitionEntries[4];
        uint16_t checkAA55;
    }__attribute__((packed)) MBR;

public:
    typedef union {
        uint8_t bytes[SECTOR_BYTES];
        uint32_t dwords[SECTOR_DWORDS];
        DIRECTORY_ENTRY dirEntries[DIRECTORIES_TABLES_PER_SECTOR];
    } SECTOR;
};

#endif /* FS_DEFS_HPP_ */