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.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
  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. * \file
  24. * \brief SdVolume class
  25. */
  26. /**
  27. * Arduino SdFat Library
  28. * Copyright (C) 2009 by William Greiman
  29. *
  30. * This file is part of the Arduino Sd2Card Library
  31. */
  32. #ifndef _SDVOLUME_H_
  33. #define _SDVOLUME_H_
  34. #include "SdFatConfig.h"
  35. #include "Sd2Card.h"
  36. #include "SdFatStructs.h"
  37. //==============================================================================
  38. // SdVolume class
  39. /**
  40. * \brief Cache for an SD data block
  41. */
  42. union cache_t {
  43. uint8_t data[512]; // Used to access cached file data blocks.
  44. uint16_t fat16[256]; // Used to access cached FAT16 entries.
  45. uint32_t fat32[128]; // Used to access cached FAT32 entries.
  46. dir_t dir[16]; // Used to access cached directory entries.
  47. mbr_t mbr; // Used to access a cached Master Boot Record.
  48. fat_boot_t fbs; // Used to access to a cached FAT boot sector.
  49. fat32_boot_t fbs32; // Used to access to a cached FAT32 boot sector.
  50. fat32_fsinfo_t fsinfo; // Used to access to a cached FAT32 FSINFO sector.
  51. };
  52. /**
  53. * \class SdVolume
  54. * \brief Access FAT16 and FAT32 volumes on SD and SDHC cards.
  55. */
  56. class SdVolume {
  57. public:
  58. // Create an instance of SdVolume
  59. SdVolume() : fatType_(0) {}
  60. /**
  61. * Clear the cache and returns a pointer to the cache. Used by the WaveRP
  62. * recorder to do raw write to the SD card. Not for normal apps.
  63. * \return A pointer to the cache buffer or zero if an error occurs.
  64. */
  65. cache_t* cacheClear() {
  66. if (!cacheFlush()) return 0;
  67. cacheBlockNumber_ = 0xFFFFFFFF;
  68. return &cacheBuffer_;
  69. }
  70. /**
  71. * Initialize a FAT volume. Try partition one first then try super
  72. * floppy format.
  73. *
  74. * \param[in] dev The Sd2Card where the volume is located.
  75. *
  76. * \return true for success, false for failure.
  77. * Reasons for failure include not finding a valid partition, not finding
  78. * a valid FAT file system or an I/O error.
  79. */
  80. bool init(Sd2Card* dev) { return init(dev, 1) ? true : init(dev, 0); }
  81. bool init(Sd2Card* dev, uint8_t part);
  82. // inline functions that return volume info
  83. uint8_t blocksPerCluster() const { return blocksPerCluster_; } //> \return The volume's cluster size in blocks.
  84. uint32_t blocksPerFat() const { return blocksPerFat_; } //> \return The number of blocks in one FAT.
  85. uint32_t clusterCount() const { return clusterCount_; } //> \return The total number of clusters in the volume.
  86. uint8_t clusterSizeShift() const { return clusterSizeShift_; } //> \return The shift count required to multiply by blocksPerCluster.
  87. uint32_t dataStartBlock() const { return dataStartBlock_; } //> \return The logical block number for the start of file data.
  88. uint8_t fatCount() const { return fatCount_; } //> \return The number of FAT structures on the volume.
  89. uint32_t fatStartBlock() const { return fatStartBlock_; } //> \return The logical block number for the start of the first FAT.
  90. uint8_t fatType() const { return fatType_; } //> \return The FAT type of the volume. Values are 12, 16 or 32.
  91. int32_t freeClusterCount();
  92. uint32_t rootDirEntryCount() const { return rootDirEntryCount_; } /** \return The number of entries in the root directory for FAT16 volumes. */
  93. /**
  94. * \return The logical block number for the start of the root directory
  95. * on FAT16 volumes or the first cluster number on FAT32 volumes.
  96. */
  97. uint32_t rootDirStart() const { return rootDirStart_; }
  98. /**
  99. * Sd2Card object for this volume
  100. * \return pointer to Sd2Card object.
  101. */
  102. Sd2Card* sdCard() { return sdCard_; }
  103. /**
  104. * Debug access to FAT table
  105. *
  106. * \param[in] n cluster number.
  107. * \param[out] v value of entry
  108. * \return true for success or false for failure
  109. */
  110. bool dbgFat(uint32_t n, uint32_t* v) { return fatGet(n, v); }
  111. private:
  112. // Allow SdBaseFile access to SdVolume private data.
  113. friend class SdBaseFile;
  114. // value for dirty argument in cacheRawBlock to indicate read from cache
  115. static bool const CACHE_FOR_READ = false;
  116. // value for dirty argument in cacheRawBlock to indicate write to cache
  117. static bool const CACHE_FOR_WRITE = true;
  118. #if USE_MULTIPLE_CARDS
  119. cache_t cacheBuffer_; // 512 byte cache for device blocks
  120. uint32_t cacheBlockNumber_; // Logical number of block in the cache
  121. Sd2Card* sdCard_; // Sd2Card object for cache
  122. bool cacheDirty_; // cacheFlush() will write block if true
  123. uint32_t cacheMirrorBlock_; // block number for mirror FAT
  124. #else
  125. static cache_t cacheBuffer_; // 512 byte cache for device blocks
  126. static uint32_t cacheBlockNumber_; // Logical number of block in the cache
  127. static Sd2Card* sdCard_; // Sd2Card object for cache
  128. static bool cacheDirty_; // cacheFlush() will write block if true
  129. static uint32_t cacheMirrorBlock_; // block number for mirror FAT
  130. #endif
  131. uint32_t allocSearchStart_; // start cluster for alloc search
  132. uint8_t blocksPerCluster_; // cluster size in blocks
  133. uint32_t blocksPerFat_; // FAT size in blocks
  134. uint32_t clusterCount_; // clusters in one FAT
  135. uint8_t clusterSizeShift_; // shift to convert cluster count to block count
  136. uint32_t dataStartBlock_; // first data block number
  137. uint8_t fatCount_; // number of FATs on volume
  138. uint32_t fatStartBlock_; // start block for first FAT
  139. uint8_t fatType_; // volume type (12, 16, OR 32)
  140. uint16_t rootDirEntryCount_; // number of entries in FAT16 root dir
  141. uint32_t rootDirStart_; // root start block for FAT16, cluster for FAT32
  142. bool allocContiguous(uint32_t count, uint32_t* curCluster);
  143. uint8_t blockOfCluster(uint32_t position) const { return (position >> 9) & (blocksPerCluster_ - 1); }
  144. uint32_t clusterStartBlock(uint32_t cluster) const { return dataStartBlock_ + ((cluster - 2) << clusterSizeShift_); }
  145. uint32_t blockNumber(uint32_t cluster, uint32_t position) const { return clusterStartBlock(cluster) + blockOfCluster(position); }
  146. cache_t* cache() { return &cacheBuffer_; }
  147. uint32_t cacheBlockNumber() const { return cacheBlockNumber_; }
  148. #if USE_MULTIPLE_CARDS
  149. bool cacheFlush();
  150. bool cacheRawBlock(uint32_t blockNumber, bool dirty);
  151. #else
  152. static bool cacheFlush();
  153. static bool cacheRawBlock(uint32_t blockNumber, bool dirty);
  154. #endif
  155. // used by SdBaseFile write to assign cache to SD location
  156. void cacheSetBlockNumber(uint32_t blockNumber, bool dirty) {
  157. cacheDirty_ = dirty;
  158. cacheBlockNumber_ = blockNumber;
  159. }
  160. void cacheSetDirty() { cacheDirty_ |= CACHE_FOR_WRITE; }
  161. bool chainSize(uint32_t beginCluster, uint32_t* size);
  162. bool fatGet(uint32_t cluster, uint32_t* value);
  163. bool fatPut(uint32_t cluster, uint32_t value);
  164. bool fatPutEOC(uint32_t cluster) { return fatPut(cluster, 0x0FFFFFFF); }
  165. bool freeChain(uint32_t cluster);
  166. bool isEOC(uint32_t cluster) const {
  167. if (FAT12_SUPPORT && fatType_ == 12) return cluster >= FAT12EOC_MIN;
  168. if (fatType_ == 16) return cluster >= FAT16EOC_MIN;
  169. return cluster >= FAT32EOC_MIN;
  170. }
  171. bool readBlock(uint32_t block, uint8_t* dst) { return sdCard_->readBlock(block, dst); }
  172. bool writeBlock(uint32_t block, const uint8_t* dst) { return sdCard_->writeBlock(block, dst); }
  173. // Deprecated functions
  174. #if ALLOW_DEPRECATED_FUNCTIONS
  175. public:
  176. /**
  177. * \deprecated Use: bool SdVolume::init(Sd2Card* dev);
  178. * \param[in] dev The SD card where the volume is located.
  179. * \return true for success or false for failure.
  180. */
  181. bool init(Sd2Card& dev) { return init(&dev); }
  182. /**
  183. * \deprecated Use: bool SdVolume::init(Sd2Card* dev, uint8_t vol);
  184. * \param[in] dev The SD card where the volume is located.
  185. * \param[in] part The partition to be used.
  186. * \return true for success or false for failure.
  187. */
  188. bool init(Sd2Card& dev, uint8_t part) { return init(&dev, part); }
  189. #endif // ALLOW_DEPRECATED_FUNCTIONS
  190. };
  191. #endif // _SDVOLUME_H_