FAT16.hh

Go to the documentation of this file.

#ifndef COSA_FAT16_HH
#define COSA_FAT16_HH

#include <SD.h>

#include "Cosa/IOStream.hh"
#include "Cosa/FS.hh"

/*
 * FAT16 file structures on SD card. Note: may only access files on the
 * root directory.
 *
 * @section Acknowledgement
 * Refactoring of Arduino Fat16 Library, Copyright (C) 2009 by William Greiman
 *
 * @section References
 * 1. http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx
 * 2. http://code.google.com/p/fat16lib/
 */
class FAT16 {
protected:
  static uint8_t const BOOTSIG0 = 0X55;

  static uint8_t const BOOTSIG1 = 0XAA;

  struct part_t {
    uint8_t boot;
    uint8_t beginHead;
    unsigned beginSector : 6;
    unsigned beginCylinderHigh : 2;
    uint8_t beginCylinderLow;
    uint8_t type;
    uint8_t endHead;
    unsigned endSector : 6;
    unsigned endCylinderHigh : 2;
    uint8_t endCylinderLow;
    uint32_t firstSector;
    uint32_t totalSectors;
  };

  struct mbr_t {
    uint8_t codeArea[440];
    uint32_t diskSignature;
    uint16_t usuallyZero;
    part_t part[4];
    uint8_t mbrSig0;
    uint8_t mbrSig1;
  };

  struct bpb_t {
    uint16_t bytesPerSector;
    uint8_t sectorsPerCluster;
    uint16_t reservedSectorCount;
    uint8_t fatCount;
    uint16_t rootDirEntryCount;
    uint16_t totalSectors16;
    uint8_t mediaType;
    uint16_t sectorsPerFat16;
    uint16_t sectorsPerTrtack;
    uint16_t headCount;
    uint32_t hidddenSectors;
    uint32_t totalSectors32;
    uint32_t sectorsPerFat32;
    uint16_t fat32Flags;
    uint16_t fat32Version;
    uint32_t fat32RootCluster;
    uint16_t fat32FSInfo;
    uint16_t fat32BackBootBlock;
    uint8_t fat32Reserved[12];
  };

  struct fbs_t {
    uint8_t jmpToBootCode[3];
    char oemName[8];
    bpb_t bpb;
    uint8_t driveNumber;
    uint8_t reserved1;
    uint8_t bootSignature;
    uint32_t volumeSerialNumber;
    char volumeLabel[11];
    char fileSystemType[8];
    uint8_t bootCode[420];
    uint8_t bootSectorSig0;
    uint8_t bootSectorSig1;
  };

  static uint16_t const EOC16 = 0XFFFF;

  static uint16_t const EOC16_MIN = 0XFFF8;

  static uint32_t const EOC32 = 0X0FFFFFFF;

  static uint32_t const EOC32_MIN = 0X0FFFFFF8;

  static uint32_t const ENTRY32_MASK = 0X0FFFFFFF;

  struct dir_t {
    uint8_t name[11];
    uint8_t attributes;
    uint8_t reservedNT;
    uint8_t creationTimeTenths;
    uint16_t creationTime;
    uint16_t creationDate;
    uint16_t lastAccessDate;
    uint16_t firstClusterHigh;
    uint16_t lastWriteTime;
    uint16_t lastWriteDate;
    uint16_t firstClusterLow;
    uint32_t fileSize;
  };

  static uint8_t const DIR_NAME_0XE5 = 0X05;
  static uint8_t const DIR_NAME_DELETED = 0XE5;
  static uint8_t const DIR_NAME_FREE = 0X00;

  static uint8_t const DIR_ATT_READ_ONLY = 0X01;
  static uint8_t const DIR_ATT_HIDDEN = 0X02;
  static uint8_t const DIR_ATT_SYSTEM = 0X04;
  static uint8_t const DIR_ATT_VOLUME_ID = 0X08;
  static uint8_t const DIR_ATT_DIRECTORY = 0X10;
  static uint8_t const DIR_ATT_ARCHIVE = 0X20;
  static uint8_t const DIR_ATT_LONG_NAME = 0X0F;
  static uint8_t const DIR_ATT_LONG_NAME_MASK = 0X3F;
  static uint8_t const DIR_ATT_DEFINED_BITS = 0X3F;
  static uint8_t const DIR_ATT_FILE_TYPE_MASK = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY);
  static uint8_t const DIR_ATT_SKIP = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY);

  static inline uint8_t DIR_IS_LONG_NAME(const dir_t* dir)
  {
    return (dir->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME;
  }

  static inline uint8_t DIR_IS_FILE(const dir_t* dir)
  {
    return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == 0;
  }

  static inline uint8_t DIR_IS_SUBDIR(const dir_t* dir)
  {
    return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == DIR_ATT_DIRECTORY;
  }

  static inline uint8_t DIR_IS_FILE_OR_SUBDIR(const dir_t* dir)
  {
    return (dir->attributes & DIR_ATT_VOLUME_ID) == 0;
  }

  typedef uint16_t fat_t;

  union cache16_t {
    uint8_t data[512];
    fat_t fat[256];
    dir_t dir[16];
    mbr_t mbr;
    fbs_t fbs;
  };

  union date_t {
    uint16_t as_uint16;
    struct {
      uint8_t day:5;
      uint8_t month:4;
      uint8_t year:7;
    };
    date_t(uint16_t y, uint8_t m, uint8_t d)
    {
      year = (y - 1980);
      month = m;
      day = d;
    }
    date_t(uint16_t date) { as_uint16 = date; }
    uint16_t YEAR() { return (1980 + year); }
    uint8_t MONTH() { return (month); }
    uint8_t DAY() { return (day); }
    operator uint16_t() { return (as_uint16); }
  };

  friend IOStream& operator<<(IOStream& outs, date_t& date);

  union time_t {
    uint16_t as_uint16;
    struct {
      uint8_t seconds:5;
      uint8_t minutes:6;
      uint8_t hours:5;
    };
    time_t(uint16_t h, uint8_t m, uint8_t s)
    {
      hours = h;
      minutes = m;
      seconds = s >> 1;
    }
    time_t(uint16_t now) { as_uint16 = now; }
    uint16_t HOURS() { return (hours); }
    uint8_t MINUTES() { return (minutes); }
    uint8_t SECONDS() { return (seconds << 1); }
    operator uint16_t() { return (as_uint16); }
  };

  friend IOStream& operator<<(IOStream& outs, time_t& time);

  static const uint16_t DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;

  static const uint16_t DEFAULT_TIME = (1 << 11);

public:

  class File : public IOStream::Device {
  public:
    File() : IOStream::Device(), m_flags(0) {}

    bool open(const char* fileName, uint8_t oflag);

    bool is_open(void) const { return (m_flags & O_RDWR) != 0; }

    bool sync();

    bool remove();

    bool close()
    {
      if (!sync()) return false;
      m_flags = 0;
      return true;
    }

    bool seek(uint32_t pos, uint8_t whence = SEEK_SET);

    uint32_t tell() { return (m_curPosition); }

    void rewind() { m_curPosition = m_curCluster = 0; }

    uint32_t size() { return (m_fileSize); }

    bool truncate(uint32_t size);

    virtual int putchar(char c);

    using IOStream::Device::write;

    virtual int write(const void *buf, size_t size);

    virtual int getchar();

    using IOStream::Device::read;

    virtual int read(void* buf, size_t size);

  protected:
    uint8_t m_flags;          // see above for bit definitions
    int16_t m_dirEntryIndex;  // index of directory entry for open file
    fat_t m_firstCluster;     // first cluster of file
    uint32_t m_fileSize;      // fileSize
    fat_t m_curCluster;       // current cluster
    uint32_t m_curPosition;   // current byte offset

    static uint8_t isEOC(fat_t cluster) { return cluster >= 0XFFF8; }
    bool addCluster();
    bool freeChain(fat_t cluster);
    bool open(uint16_t entry, uint8_t oflag);
    bool dirEntry(dir_t* dir);
  };

  enum {
    LS_DATE = 1,
    LS_SIZE = 2
  } __attribute__((packed));

  static bool begin(SD* sd, uint8_t partion);

  static bool begin(SD* sd);

  static void ls(IOStream& outs, uint8_t flags = 0);

  static bool rm(const char* fileName)
  {
    FAT16::File file;
    if (!file.open(fileName, O_WRITE)) return false;
    return file.remove();
  }

protected:
  // SD device (Fix: Should be an IOBlock::Device)
  static SD *device;

  // Volume info
  static bool volumeInitialized;        // true if volume has been initialized
  static uint8_t fatCount;              // number of FATs
  static uint8_t blocksPerCluster;      // must be power of 2
  static uint16_t rootDirEntryCount;    // should be 512 for FAT16
  static fat_t blocksPerFat;            // number of blocks in one FAT
  static fat_t clusterCount;            // total clusters in volume
  static uint32_t fatStartBlock;        // start of first FAT
  static uint32_t rootDirStartBlock;    // start of root dir
  static uint32_t dataStartBlock;       // start of data clusters

  // block cache
  static uint8_t const CACHE_FOR_READ  = 0;    // cache a block for read
  static uint8_t const CACHE_FOR_WRITE = 1;    // cache a block and set dirty
  static cache16_t cacheBuffer;         // 512 byte cache for raw blocks
  static uint32_t cacheBlockNumber;     // Logical number of block in the cache
  static uint8_t cacheDirty;            // cacheFlush() will write block if true
  static uint32_t cacheMirrorBlock;     // mirror block for second FAT

  // callback function for date/time
  static void (*dateTime)(uint16_t* date, uint16_t* time);

  // define fields in flags_ require sync directory entry
  static uint8_t const F_OFLAG = O_RDWR | O_APPEND | O_SYNC;
  static uint8_t const F_FILE_DIR_DIRTY = 0X80;

  static bool make83Name(const char* str, uint8_t* name);

  static uint8_t blockOfCluster(uint32_t position)
  {
    return (position >> 9) & (blocksPerCluster - 1);
  }
  static uint16_t cacheDataOffset(uint32_t position)
  {
    return position & 0X1FF;
  }
  static dir_t* cacheDirEntry(uint16_t index, uint8_t action = 0);
  static uint8_t cacheRawBlock(uint32_t blockNumber, uint8_t action = 0);
  static uint8_t cacheFlush(void);
  static void cacheSetDirty(void)
  {
    cacheDirty |= CACHE_FOR_WRITE;
  }
  static uint32_t dataBlockLba(fat_t cluster, uint8_t blockOfCluster)
  {
    return (dataStartBlock +
            (uint32_t)(cluster - 2) * blocksPerCluster +
            blockOfCluster);
  }

  static bool fatGet(fat_t cluster, fat_t* value);
  static bool fatPut(fat_t cluster, fat_t value);

  static bool read(dir_t* dir, uint16_t* index, uint8_t skip = DIR_ATT_SKIP);
  static void printDirName(IOStream& outs, const dir_t& dir, uint8_t width);
};

#endif