ExFatPartition.h

Go to the documentation of this file.

 
#ifndef ExFatPartition_h
#define ExFatPartition_h
#include "../common/BlockDevice.h"
#include "../common/FsCache.h"
#include "../common/SysCall.h"
#include "ExFatConfig.h"
#include "ExFatTypes.h"
const uint8_t FAT_TYPE_EXFAT = 64;
 
class ExFatFile;
 
//==============================================================================
class ExFatPartition
{
  public:
    ExFatPartition()
    {
    }
    uint32_t bytesPerCluster() const
    {
        return m_bytesPerCluster;
    }
    uint8_t bytesPerClusterShift() const
    {
        return m_bytesPerSectorShift + m_sectorsPerClusterShift;
    }
    uint16_t bytesPerSector() const
    {
        return m_bytesPerSector;
    }
    uint8_t bytesPerSectorShift() const
    {
        return m_bytesPerSectorShift;
    }
 
    uint8_t *cacheClear()
    {
        return m_dataCache.clear();
    }
    uint32_t clusterCount() const
    {
        return m_clusterCount;
    }
    uint32_t clusterHeapStartSector() const
    {
        return m_clusterHeapStartSector;
    }
    uint32_t fatLength() const
    {
        return m_fatLength;
    }
    uint32_t fatStartSector() const
    {
        return m_fatStartSector;
    }
    uint8_t fatType() const
    {
        return m_fatType;
    }
    uint32_t freeClusterCount();
    bool init(BlockDevice *dev, uint8_t part);
    bool isBusy()
    {
        return m_blockDev->isBusy();
    }
    uint32_t rootDirectoryCluster() const
    {
        return m_rootDirectoryCluster;
    }
    uint32_t rootLength();
    uint32_t sectorsPerCluster() const
    {
        return 1UL << m_sectorsPerClusterShift;
    }
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    // Use sectorsPerCluster(). blocksPerCluster() will be removed in the future.
    uint32_t blocksPerCluster() __attribute__((deprecated))
    {
        return sectorsPerCluster();
    }  // NOLINT
#endif // DOXYGEN_SHOULD_SKIP_THIS
    uint8_t sectorsPerClusterShift() const
    {
        return m_sectorsPerClusterShift;
    }
    //----------------------------------------------------------------------------
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void checkUpcase(print_t *pr);
    bool printDir(print_t *pr, ExFatFile *file);
    void dmpBitmap(print_t *pr);
    void dmpCluster(print_t *pr, uint32_t cluster, uint32_t offset, uint32_t count);
    void dmpFat(print_t *pr, uint32_t start, uint32_t count);
    void dmpSector(print_t *pr, uint32_t sector);
    bool printVolInfo(print_t *pr);
    void printFat(print_t *pr);
    void printUpcase(print_t *pr);
#endif // DOXYGEN_SHOULD_SKIP_THIS
       //----------------------------------------------------------------------------
  private:
    friend class ExFatFile;
    uint32_t bitmapFind(uint32_t cluster, uint32_t count);
    bool bitmapModify(uint32_t cluster, uint32_t count, bool value);
    //----------------------------------------------------------------------------
    // Cache functions.
    uint8_t *bitmapCacheGet(uint32_t sector, uint8_t option)
    {
#if USE_EXFAT_BITMAP_CACHE
        return m_bitmapCache.get(sector, option);
#else  // USE_EXFAT_BITMAP_CACHE
        return m_dataCache.get(sector, option);
#endif // USE_EXFAT_BITMAP_CACHE
    }
    void cacheInit(BlockDevice *dev)
    {
#if USE_EXFAT_BITMAP_CACHE
        m_bitmapCache.init(dev);
#endif // USE_EXFAT_BITMAP_CACHE
        m_dataCache.init(dev);
    }
    bool cacheSync()
    {
#if USE_EXFAT_BITMAP_CACHE
        return m_bitmapCache.sync() && m_dataCache.sync() && syncDevice();
#else  // USE_EXFAT_BITMAP_CACHE
        return m_dataCache.sync() && syncDevice();
#endif // USE_EXFAT_BITMAP_CACHE
    }
    void dataCacheDirty()
    {
        m_dataCache.dirty();
    }
    void dataCacheInvalidate()
    {
        m_dataCache.invalidate();
    }
    uint8_t *dataCacheGet(uint32_t sector, uint8_t option)
    {
        return m_dataCache.get(sector, option);
    }
    uint32_t dataCacheSector()
    {
        return m_dataCache.sector();
    }
    bool dataCacheSync()
    {
        return m_dataCache.sync();
    }
    //----------------------------------------------------------------------------
    uint32_t clusterMask() const
    {
        return m_clusterMask;
    }
    uint32_t clusterStartSector(uint32_t cluster)
    {
        return m_clusterHeapStartSector + ((cluster - 2) << m_sectorsPerClusterShift);
    }
    uint8_t *dirCache(DirPos_t *pos, uint8_t options);
    int8_t dirSeek(DirPos_t *pos, uint32_t offset);
    uint8_t fatGet(uint32_t cluster, uint32_t *value);
    bool fatPut(uint32_t cluster, uint32_t value);
    uint32_t chainSize(uint32_t cluster);
    bool freeChain(uint32_t cluster);
    uint16_t sectorMask() const
    {
        return m_sectorMask;
    }
    bool syncDevice()
    {
        return m_blockDev->syncDevice();
    }
    bool cacheSafeRead(uint32_t sector, uint8_t *dst)
    {
        return m_dataCache.cacheSafeRead(sector, dst);
    }
    bool cacheSafeWrite(uint32_t sector, const uint8_t *src)
    {
        return m_dataCache.cacheSafeWrite(sector, src);
    }
    bool cacheSafeRead(uint32_t sector, uint8_t *dst, size_t count)
    {
        return m_dataCache.cacheSafeRead(sector, dst, count);
    }
    bool cacheSafeWrite(uint32_t sector, const uint8_t *src, size_t count)
    {
        return m_dataCache.cacheSafeWrite(sector, src, count);
    }
    bool readSector(uint32_t sector, uint8_t *dst)
    {
        return m_blockDev->readSector(sector, dst);
    }
    bool writeSector(uint32_t sector, const uint8_t *src)
    {
        return m_blockDev->writeSector(sector, src);
    }
    //----------------------------------------------------------------------------
    static const uint8_t m_bytesPerSectorShift = 9;
    static const uint16_t m_bytesPerSector = 512;
    static const uint16_t m_sectorMask = 0x1FF;
    //----------------------------------------------------------------------------
#if USE_EXFAT_BITMAP_CACHE
    FsCache m_bitmapCache;
#endif // USE_EXFAT_BITMAP_CACHE
    FsCache m_dataCache;
    uint32_t m_bitmapStart;
    uint32_t m_fatStartSector;
    uint32_t m_fatLength;
    uint32_t m_clusterHeapStartSector;
    uint32_t m_clusterCount;
    uint32_t m_rootDirectoryCluster;
    uint32_t m_clusterMask;
    uint32_t m_bytesPerCluster;
    BlockDevice *m_blockDev;
    uint8_t m_fatType = 0;
    uint8_t m_sectorsPerClusterShift;
};
#endif // ExFatPartition_h