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 SdVolume class*//*** Arduino SdFat Library* Copyright (C) 2009 by William Greiman** This file is part of the Arduino Sd2Card Library*/#ifndef _SDVOLUME_H_#define _SDVOLUME_H_#include "SdFatConfig.h"#include "Sd2Card.h"#include "SdFatStructs.h"//==============================================================================// SdVolume class/*** \brief Cache for an SD data block*/union cache_t {uint8_t data[512]; // Used to access cached file data blocks.uint16_t fat16[256]; // Used to access cached FAT16 entries.uint32_t fat32[128]; // Used to access cached FAT32 entries.dir_t dir[16]; // Used to access cached directory entries.mbr_t mbr; // Used to access a cached Master Boot Record.fat_boot_t fbs; // Used to access to a cached FAT boot sector.fat32_boot_t fbs32; // Used to access to a cached FAT32 boot sector.fat32_fsinfo_t fsinfo; // Used to access to a cached FAT32 FSINFO sector.};/*** \class SdVolume* \brief Access FAT16 and FAT32 volumes on SD and SDHC cards.*/class SdVolume {public:// Create an instance of SdVolumeSdVolume() : fatType_(0) {}/*** Clear the cache and returns a pointer to the cache. Used by the WaveRP* recorder to do raw write to the SD card. Not for normal apps.* \return A pointer to the cache buffer or zero if an error occurs.*/cache_t* cacheClear() {if (!cacheFlush()) return 0;cacheBlockNumber_ = 0xFFFFFFFF;return &cacheBuffer_;}/*** Initialize a FAT volume. Try partition one first then try super* floppy format.** \param[in] dev The Sd2Card where the volume is located.** \return true for success, false for failure.* Reasons for failure include not finding a valid partition, not finding* a valid FAT file system or an I/O error.*/bool init(Sd2Card* dev) { return init(dev, 1) ? true : init(dev, 0); }bool init(Sd2Card* dev, uint8_t part);// inline functions that return volume infouint8_t blocksPerCluster() const { return blocksPerCluster_; } //> \return The volume's cluster size in blocks.uint32_t blocksPerFat() const { return blocksPerFat_; } //> \return The number of blocks in one FAT.uint32_t clusterCount() const { return clusterCount_; } //> \return The total number of clusters in the volume.uint8_t clusterSizeShift() const { return clusterSizeShift_; } //> \return The shift count required to multiply by blocksPerCluster.uint32_t dataStartBlock() const { return dataStartBlock_; } //> \return The logical block number for the start of file data.uint8_t fatCount() const { return fatCount_; } //> \return The number of FAT structures on the volume.uint32_t fatStartBlock() const { return fatStartBlock_; } //> \return The logical block number for the start of the first FAT.uint8_t fatType() const { return fatType_; } //> \return The FAT type of the volume. Values are 12, 16 or 32.int32_t freeClusterCount();uint32_t rootDirEntryCount() const { return rootDirEntryCount_; } /** \return The number of entries in the root directory for FAT16 volumes. *//*** \return The logical block number for the start of the root directory* on FAT16 volumes or the first cluster number on FAT32 volumes.*/uint32_t rootDirStart() const { return rootDirStart_; }/*** Sd2Card object for this volume* \return pointer to Sd2Card object.*/Sd2Card* sdCard() { return sdCard_; }/*** Debug access to FAT table** \param[in] n cluster number.* \param[out] v value of entry* \return true for success or false for failure*/bool dbgFat(uint32_t n, uint32_t* v) { return fatGet(n, v); }private:// Allow SdBaseFile access to SdVolume private data.friend class SdBaseFile;// value for dirty argument in cacheRawBlock to indicate read from cachestatic bool const CACHE_FOR_READ = false;// value for dirty argument in cacheRawBlock to indicate write to cachestatic bool const CACHE_FOR_WRITE = true;#if USE_MULTIPLE_CARDScache_t cacheBuffer_; // 512 byte cache for device blocksuint32_t cacheBlockNumber_; // Logical number of block in the cacheSd2Card* sdCard_; // Sd2Card object for cachebool cacheDirty_; // cacheFlush() will write block if trueuint32_t cacheMirrorBlock_; // block number for mirror FAT#elsestatic cache_t cacheBuffer_; // 512 byte cache for device blocksstatic uint32_t cacheBlockNumber_; // Logical number of block in the cachestatic Sd2Card* sdCard_; // Sd2Card object for cachestatic bool cacheDirty_; // cacheFlush() will write block if truestatic uint32_t cacheMirrorBlock_; // block number for mirror FAT#endifuint32_t allocSearchStart_; // start cluster for alloc searchuint8_t blocksPerCluster_; // cluster size in blocksuint32_t blocksPerFat_; // FAT size in blocksuint32_t clusterCount_; // clusters in one FATuint8_t clusterSizeShift_; // shift to convert cluster count to block countuint32_t dataStartBlock_; // first data block numberuint8_t fatCount_; // number of FATs on volumeuint32_t fatStartBlock_; // start block for first FATuint8_t fatType_; // volume type (12, 16, OR 32)uint16_t rootDirEntryCount_; // number of entries in FAT16 root diruint32_t rootDirStart_; // root start block for FAT16, cluster for FAT32bool allocContiguous(uint32_t count, uint32_t* curCluster);uint8_t blockOfCluster(uint32_t position) const { return (position >> 9) & (blocksPerCluster_ - 1); }uint32_t clusterStartBlock(uint32_t cluster) const { return dataStartBlock_ + ((cluster - 2) << clusterSizeShift_); }uint32_t blockNumber(uint32_t cluster, uint32_t position) const { return clusterStartBlock(cluster) + blockOfCluster(position); }cache_t* cache() { return &cacheBuffer_; }uint32_t cacheBlockNumber() const { return cacheBlockNumber_; }#if USE_MULTIPLE_CARDSbool cacheFlush();bool cacheRawBlock(uint32_t blockNumber, bool dirty);#elsestatic bool cacheFlush();static bool cacheRawBlock(uint32_t blockNumber, bool dirty);#endif// used by SdBaseFile write to assign cache to SD locationvoid cacheSetBlockNumber(uint32_t blockNumber, bool dirty) {cacheDirty_ = dirty;cacheBlockNumber_ = blockNumber;}void cacheSetDirty() { cacheDirty_ |= CACHE_FOR_WRITE; }bool chainSize(uint32_t beginCluster, uint32_t* size);bool fatGet(uint32_t cluster, uint32_t* value);bool fatPut(uint32_t cluster, uint32_t value);bool fatPutEOC(uint32_t cluster) { return fatPut(cluster, 0x0FFFFFFF); }bool freeChain(uint32_t cluster);bool isEOC(uint32_t cluster) const {if (FAT12_SUPPORT && fatType_ == 12) return cluster >= FAT12EOC_MIN;if (fatType_ == 16) return cluster >= FAT16EOC_MIN;return cluster >= FAT32EOC_MIN;}bool readBlock(uint32_t block, uint8_t* dst) { return sdCard_->readBlock(block, dst); }bool writeBlock(uint32_t block, const uint8_t* dst) { return sdCard_->writeBlock(block, dst); }// Deprecated functions#if ALLOW_DEPRECATED_FUNCTIONSpublic:/*** \deprecated Use: bool SdVolume::init(Sd2Card* dev);* \param[in] dev The SD card where the volume is located.* \return true for success or false for failure.*/bool init(Sd2Card& dev) { return init(&dev); }/*** \deprecated Use: bool SdVolume::init(Sd2Card* dev, uint8_t vol);* \param[in] dev The SD card where the volume is located.* \param[in] part The partition to be used.* \return true for success or false for failure.*/bool init(Sd2Card& dev, uint8_t part) { return init(&dev, part); }#endif // ALLOW_DEPRECATED_FUNCTIONS};#endif // _SDVOLUME_H_