My Marlin configs for Fabrikator Mini and CTC i3 Pro B
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

SdVolume.h 9.2KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227
  1. /**
  2. * Marlin 3D Printer Firmware
  3. * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  4. *
  5. * Based on Sprinter and grbl.
  6. * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  7. *
  8. * This program is free software: you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation, either version 3 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  20. *
  21. */
  22. /**
  23. * Arduino SdFat Library
  24. * Copyright (C) 2009 by William Greiman
  25. *
  26. * This file is part of the Arduino Sd2Card Library
  27. */
  28. #include "Marlin.h"
  29. #if ENABLED(SDSUPPORT)
  30. #ifndef SdVolume_h
  31. #define SdVolume_h
  32. /**
  33. * \file
  34. * \brief SdVolume class
  35. */
  36. #include "SdFatConfig.h"
  37. #include "Sd2Card.h"
  38. #include "SdFatStructs.h"
  39. //==============================================================================
  40. // SdVolume class
  41. /**
  42. * \brief Cache for an SD data block
  43. */
  44. union cache_t {
  45. /** Used to access cached file data blocks. */
  46. uint8_t data[512];
  47. /** Used to access cached FAT16 entries. */
  48. uint16_t fat16[256];
  49. /** Used to access cached FAT32 entries. */
  50. uint32_t fat32[128];
  51. /** Used to access cached directory entries. */
  52. dir_t dir[16];
  53. /** Used to access a cached Master Boot Record. */
  54. mbr_t mbr;
  55. /** Used to access to a cached FAT boot sector. */
  56. fat_boot_t fbs;
  57. /** Used to access to a cached FAT32 boot sector. */
  58. fat32_boot_t fbs32;
  59. /** Used to access to a cached FAT32 FSINFO sector. */
  60. fat32_fsinfo_t fsinfo;
  61. };
  62. //------------------------------------------------------------------------------
  63. /**
  64. * \class SdVolume
  65. * \brief Access FAT16 and FAT32 volumes on SD and SDHC cards.
  66. */
  67. class SdVolume {
  68. public:
  69. /** Create an instance of SdVolume */
  70. SdVolume() : fatType_(0) {}
  71. /** Clear the cache and returns a pointer to the cache. Used by the WaveRP
  72. * recorder to do raw write to the SD card. Not for normal apps.
  73. * \return A pointer to the cache buffer or zero if an error occurs.
  74. */
  75. cache_t* cacheClear() {
  76. if (!cacheFlush()) return 0;
  77. cacheBlockNumber_ = 0XFFFFFFFF;
  78. return &cacheBuffer_;
  79. }
  80. /** Initialize a FAT volume. Try partition one first then try super
  81. * floppy format.
  82. *
  83. * \param[in] dev The Sd2Card where the volume is located.
  84. *
  85. * \return The value one, true, is returned for success and
  86. * the value zero, false, is returned for failure. Reasons for
  87. * failure include not finding a valid partition, not finding a valid
  88. * FAT file system or an I/O error.
  89. */
  90. bool init(Sd2Card* dev) { return init(dev, 1) ? true : init(dev, 0);}
  91. bool init(Sd2Card* dev, uint8_t part);
  92. // inline functions that return volume info
  93. /** \return The volume's cluster size in blocks. */
  94. uint8_t blocksPerCluster() const {return blocksPerCluster_;}
  95. /** \return The number of blocks in one FAT. */
  96. uint32_t blocksPerFat() const {return blocksPerFat_;}
  97. /** \return The total number of clusters in the volume. */
  98. uint32_t clusterCount() const {return clusterCount_;}
  99. /** \return The shift count required to multiply by blocksPerCluster. */
  100. uint8_t clusterSizeShift() const {return clusterSizeShift_;}
  101. /** \return The logical block number for the start of file data. */
  102. uint32_t dataStartBlock() const {return dataStartBlock_;}
  103. /** \return The number of FAT structures on the volume. */
  104. uint8_t fatCount() const {return fatCount_;}
  105. /** \return The logical block number for the start of the first FAT. */
  106. uint32_t fatStartBlock() const {return fatStartBlock_;}
  107. /** \return The FAT type of the volume. Values are 12, 16 or 32. */
  108. uint8_t fatType() const {return fatType_;}
  109. int32_t freeClusterCount();
  110. /** \return The number of entries in the root directory for FAT16 volumes. */
  111. uint32_t rootDirEntryCount() const {return rootDirEntryCount_;}
  112. /** \return The logical block number for the start of the root directory
  113. on FAT16 volumes or the first cluster number on FAT32 volumes. */
  114. uint32_t rootDirStart() const {return rootDirStart_;}
  115. /** Sd2Card object for this volume
  116. * \return pointer to Sd2Card object.
  117. */
  118. Sd2Card* sdCard() {return sdCard_;}
  119. /** Debug access to FAT table
  120. *
  121. * \param[in] n cluster number.
  122. * \param[out] v value of entry
  123. * \return true for success or false for failure
  124. */
  125. bool dbgFat(uint32_t n, uint32_t* v) {return fatGet(n, v);}
  126. //------------------------------------------------------------------------------
  127. private:
  128. // Allow SdBaseFile access to SdVolume private data.
  129. friend class SdBaseFile;
  130. // value for dirty argument in cacheRawBlock to indicate read from cache
  131. static bool const CACHE_FOR_READ = false;
  132. // value for dirty argument in cacheRawBlock to indicate write to cache
  133. static bool const CACHE_FOR_WRITE = true;
  134. #if USE_MULTIPLE_CARDS
  135. cache_t cacheBuffer_; // 512 byte cache for device blocks
  136. uint32_t cacheBlockNumber_; // Logical number of block in the cache
  137. Sd2Card* sdCard_; // Sd2Card object for cache
  138. bool cacheDirty_; // cacheFlush() will write block if true
  139. uint32_t cacheMirrorBlock_; // block number for mirror FAT
  140. #else // USE_MULTIPLE_CARDS
  141. static cache_t cacheBuffer_; // 512 byte cache for device blocks
  142. static uint32_t cacheBlockNumber_; // Logical number of block in the cache
  143. static Sd2Card* sdCard_; // Sd2Card object for cache
  144. static bool cacheDirty_; // cacheFlush() will write block if true
  145. static uint32_t cacheMirrorBlock_; // block number for mirror FAT
  146. #endif // USE_MULTIPLE_CARDS
  147. uint32_t allocSearchStart_; // start cluster for alloc search
  148. uint8_t blocksPerCluster_; // cluster size in blocks
  149. uint32_t blocksPerFat_; // FAT size in blocks
  150. uint32_t clusterCount_; // clusters in one FAT
  151. uint8_t clusterSizeShift_; // shift to convert cluster count to block count
  152. uint32_t dataStartBlock_; // first data block number
  153. uint8_t fatCount_; // number of FATs on volume
  154. uint32_t fatStartBlock_; // start block for first FAT
  155. uint8_t fatType_; // volume type (12, 16, OR 32)
  156. uint16_t rootDirEntryCount_; // number of entries in FAT16 root dir
  157. uint32_t rootDirStart_; // root start block for FAT16, cluster for FAT32
  158. //----------------------------------------------------------------------------
  159. bool allocContiguous(uint32_t count, uint32_t* curCluster);
  160. uint8_t blockOfCluster(uint32_t position) const {
  161. return (position >> 9) & (blocksPerCluster_ - 1);
  162. }
  163. uint32_t clusterStartBlock(uint32_t cluster) const {
  164. return dataStartBlock_ + ((cluster - 2) << clusterSizeShift_);
  165. }
  166. uint32_t blockNumber(uint32_t cluster, uint32_t position) const {
  167. return clusterStartBlock(cluster) + blockOfCluster(position);
  168. }
  169. cache_t* cache() {return &cacheBuffer_;}
  170. uint32_t cacheBlockNumber() {return cacheBlockNumber_;}
  171. #if USE_MULTIPLE_CARDS
  172. bool cacheFlush();
  173. bool cacheRawBlock(uint32_t blockNumber, bool dirty);
  174. #else // USE_MULTIPLE_CARDS
  175. static bool cacheFlush();
  176. static bool cacheRawBlock(uint32_t blockNumber, bool dirty);
  177. #endif // USE_MULTIPLE_CARDS
  178. // used by SdBaseFile write to assign cache to SD location
  179. void cacheSetBlockNumber(uint32_t blockNumber, bool dirty) {
  180. cacheDirty_ = dirty;
  181. cacheBlockNumber_ = blockNumber;
  182. }
  183. void cacheSetDirty() {cacheDirty_ |= CACHE_FOR_WRITE;}
  184. bool chainSize(uint32_t beginCluster, uint32_t* size);
  185. bool fatGet(uint32_t cluster, uint32_t* value);
  186. bool fatPut(uint32_t cluster, uint32_t value);
  187. bool fatPutEOC(uint32_t cluster) {
  188. return fatPut(cluster, 0x0FFFFFFF);
  189. }
  190. bool freeChain(uint32_t cluster);
  191. bool isEOC(uint32_t cluster) const {
  192. if (FAT12_SUPPORT && fatType_ == 12) return cluster >= FAT12EOC_MIN;
  193. if (fatType_ == 16) return cluster >= FAT16EOC_MIN;
  194. return cluster >= FAT32EOC_MIN;
  195. }
  196. bool readBlock(uint32_t block, uint8_t* dst) {
  197. return sdCard_->readBlock(block, dst);
  198. }
  199. bool writeBlock(uint32_t block, const uint8_t* dst) {
  200. return sdCard_->writeBlock(block, dst);
  201. }
  202. //------------------------------------------------------------------------------
  203. // Deprecated functions - suppress cpplint warnings with NOLINT comment
  204. #if ALLOW_DEPRECATED_FUNCTIONS && !defined(DOXYGEN)
  205. public:
  206. /** \deprecated Use: bool SdVolume::init(Sd2Card* dev);
  207. * \param[in] dev The SD card where the volume is located.
  208. * \return true for success or false for failure.
  209. */
  210. bool init(Sd2Card& dev) {return init(&dev);} // NOLINT
  211. /** \deprecated Use: bool SdVolume::init(Sd2Card* dev, uint8_t vol);
  212. * \param[in] dev The SD card where the volume is located.
  213. * \param[in] part The partition to be used.
  214. * \return true for success or false for failure.
  215. */
  216. bool init(Sd2Card& dev, uint8_t part) { // NOLINT
  217. return init(&dev, part);
  218. }
  219. #endif // ALLOW_DEPRECATED_FUNCTIONS
  220. };
  221. #endif // SdVolume
  222. #endif