andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge pull request #7471 from thinkyhead/bf1_cleanups_aug9 

Miscellaneous style tweaks
pull/1/head
Scott Lahteine 7 years ago
committed by GitHub
parent
419c8969a7 3be9c19f12
commit
6172f150c2
16 changed files with 367 additions and 363 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 20
      Marlin/Conditionals_post.h
  2. 9
      Marlin/Marlin_main.cpp
  3. 104
      Marlin/Sd2Card.cpp
  4. 22
      Marlin/Sd2Card.h
  5. 300
      Marlin/SdBaseFile.cpp
  6. 26
      Marlin/SdBaseFile.h
  7. 72
      Marlin/SdFatStructs.h
  8. 52
      Marlin/SdInfo.h
  9. 96
      Marlin/SdVolume.cpp
  10. 2
      Marlin/SdVolume.h
  11. 2
      Marlin/example_configurations/Creality/CR-10/Configuration.h
  12. 2
      Marlin/pca9632.cpp
  13. 2
      Marlin/pins_MELZI_CREALITY.h
  14. 2
      Marlin/pins_MELZI_MAKR3D.h
  15. 6
      Marlin/softspi.h
  16. 13
      Marlin/ultralcd.cpp

20
Marlin/Conditionals_post.h
View File

@ -681,16 +681,6 @@
#endif
#define WRITE_FAN_N(n, v) WRITE_FAN##n(v)
/**
* Heater & Fan Pausing
*/
#if FAN_COUNT == 0
#undef PROBING_FANS_OFF
#endif
#define QUIET_PROBING (HAS_BED_PROBE && (ENABLED(PROBING_HEATERS_OFF) || ENABLED(PROBING_FANS_OFF) || DELAY_BEFORE_PROBING > 0))
#define HEATER_IDLE_HANDLER (ENABLED(ADVANCED_PAUSE_FEATURE) || ENABLED(PROBING_HEATERS_OFF))
/**
* Servos and probes
*/
@ -702,7 +692,6 @@
#endif
#define PROBE_PIN_CONFIGURED (HAS_Z_MIN_PROBE_PIN || (HAS_Z_MIN && ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN)))
#define HAS_BED_PROBE (PROBE_SELECTED && PROBE_PIN_CONFIGURED && DISABLED(PROBE_MANUALLY))
#if ENABLED(Z_PROBE_ALLEN_KEY)
@ -743,6 +732,15 @@
#define Z_PROBE_OFFSET_FROM_EXTRUDER 0
#endif
/**
* Heater & Fan Pausing
*/
#if FAN_COUNT == 0
#undef PROBING_FANS_OFF
#endif
#define QUIET_PROBING (HAS_BED_PROBE && (ENABLED(PROBING_HEATERS_OFF) || ENABLED(PROBING_FANS_OFF) || DELAY_BEFORE_PROBING > 0))
#define HEATER_IDLE_HANDLER (ENABLED(ADVANCED_PAUSE_FEATURE) || ENABLED(PROBING_HEATERS_OFF))
/**
* Delta radius/rod trimmers/angle trimmers
*/

9
Marlin/Marlin_main.cpp
View File

@ -2359,10 +2359,11 @@ static void clean_up_after_endstop_or_probe_move() {
const float nx = lx - (X_PROBE_OFFSET_FROM_EXTRUDER), ny = ly - (Y_PROBE_OFFSET_FROM_EXTRUDER);
if (printable) {
if (!position_is_reachable_by_probe_xy(lx, ly)) return NAN;
}
else if (!position_is_reachable_xy(nx, ny)) return NAN;
if (printable
? !position_is_reachable_xy(nx, ny)
: !position_is_reachable_by_probe_xy(lx, ly)
) return NAN;
const float old_feedrate_mm_s = feedrate_mm_s;

104
Marlin/Sd2Card.cpp
View File

@ -55,7 +55,7 @@
//------------------------------------------------------------------------------
/** SPI receive a byte */
static uint8_t spiRec() {
SPDR = 0XFF;
SPDR = 0xFF;
while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
return SPDR;
}
@ -64,11 +64,11 @@
static inline __attribute__((always_inline))
void spiRead(uint8_t* buf, uint16_t nbyte) {
if (nbyte-- == 0) return;
SPDR = 0XFF;
SPDR = 0xFF;
for (uint16_t i = 0; i < nbyte; i++) {
while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
buf[i] = SPDR;
SPDR = 0XFF;
SPDR = 0xFF;
}
while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
buf[nbyte] = SPDR;
@ -103,7 +103,7 @@
uint8_t data = 0;
// no interrupts during byte receive - about 8 us
cli();
// output pin high - like sending 0XFF
// output pin high - like sending 0xFF
WRITE(SPI_MOSI_PIN, HIGH);
for (uint8_t i = 0; i < 8; i++) {
@ -137,7 +137,7 @@
for (uint8_t i = 0; i < 8; i++) {
WRITE(SPI_SCK_PIN, LOW);
WRITE(SPI_MOSI_PIN, data & 0X80);
WRITE(SPI_MOSI_PIN, data & 0x80);
data <<= 1;
@ -177,16 +177,16 @@ uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) {
for (int8_t s = 24; s >= 0; s -= 8) spiSend(arg >> s);
// send CRC
uint8_t crc = 0XFF;
if (cmd == CMD0) crc = 0X95; // correct crc for CMD0 with arg 0
if (cmd == CMD8) crc = 0X87; // correct crc for CMD8 with arg 0X1AA
uint8_t crc = 0xFF;
if (cmd == CMD0) crc = 0x95; // correct crc for CMD0 with arg 0
if (cmd == CMD8) crc = 0x87; // correct crc for CMD8 with arg 0x1AA
spiSend(crc);
// skip stuff byte for stop read
if (cmd == CMD12) spiRec();
// wait for response
for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++) { /* Intentionally left empty */ }
for (uint8_t i = 0; ((status_ = spiRec()) & 0x80) && i != 0xFF; i++) { /* Intentionally left empty */ }
return status_;
}
//------------------------------------------------------------------------------
@ -244,7 +244,7 @@ void Sd2Card::chipSelectLow() {
*/
bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
csd_t csd;
if (!readCSD(&csd)) goto fail;
if (!readCSD(&csd)) goto FAIL;
// check for single block erase
if (!csd.v1.erase_blk_en) {
// erase size mask
@ -252,7 +252,7 @@ bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
if ((firstBlock & m) != 0 || ((lastBlock + 1) & m) != 0) {
// error card can't erase specified area
error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
goto fail;
goto FAIL;
}
}
if (type_ != SD_CARD_TYPE_SDHC) {
@ -263,15 +263,15 @@ bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
|| cardCommand(CMD33, lastBlock)
|| cardCommand(CMD38, 0)) {
error(SD_CARD_ERROR_ERASE);
goto fail;
goto FAIL;
}
if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
error(SD_CARD_ERROR_ERASE_TIMEOUT);
goto fail;
goto FAIL;
}
chipSelectHigh();
return true;
fail:
FAIL:
chipSelectHigh();
return false;
}
@ -329,13 +329,13 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
#endif // SOFTWARE_SPI
// must supply min of 74 clock cycles with CS high.
for (uint8_t i = 0; i < 10; i++) spiSend(0XFF);
for (uint8_t i = 0; i < 10; i++) spiSend(0xFF);
// command to go idle in SPI mode
while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {
if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
error(SD_CARD_ERROR_CMD0);
goto fail;
goto FAIL;
}
}
// check SD version
@ -345,29 +345,29 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
else {
// only need last byte of r7 response
for (uint8_t i = 0; i < 4; i++) status_ = spiRec();
if (status_ != 0XAA) {
if (status_ != 0xAA) {
error(SD_CARD_ERROR_CMD8);
goto fail;
goto FAIL;
}
type(SD_CARD_TYPE_SD2);
}
// initialize card and send host supports SDHC if SD2
arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
arg = type() == SD_CARD_TYPE_SD2 ? 0x40000000 : 0;
while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {
// check for timeout
if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
error(SD_CARD_ERROR_ACMD41);
goto fail;
goto FAIL;
}
}
// if SD2 read OCR register to check for SDHC card
if (type() == SD_CARD_TYPE_SD2) {
if (cardCommand(CMD58, 0)) {
error(SD_CARD_ERROR_CMD58);
goto fail;
goto FAIL;
}
if ((spiRec() & 0XC0) == 0XC0) type(SD_CARD_TYPE_SDHC);
if ((spiRec() & 0xC0) == 0xC0) type(SD_CARD_TYPE_SDHC);
// discard rest of ocr - contains allowed voltage range
for (uint8_t i = 0; i < 3; i++) spiRec();
}
@ -380,7 +380,7 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
return true;
#endif // SOFTWARE_SPI
fail:
FAIL:
chipSelectHigh();
return false;
}
@ -473,7 +473,7 @@ static const uint16_t crctab[] PROGMEM = {
static uint16_t CRC_CCITT(const uint8_t* data, size_t n) {
uint16_t crc = 0;
for (size_t i = 0; i < n; i++) {
crc = pgm_read_word(&crctab[(crc >> 8 ^ data[i]) & 0XFF]) ^ (crc << 8);
crc = pgm_read_word(&crctab[(crc >> 8 ^ data[i]) & 0xFF]) ^ (crc << 8);
}
return crc;
}
@ -486,12 +486,12 @@ bool Sd2Card::readData(uint8_t* dst, uint16_t count) {
while ((status_ = spiRec()) == 0XFF) {
if (((uint16_t)millis() - t0) > SD_READ_TIMEOUT) {
error(SD_CARD_ERROR_READ_TIMEOUT);
goto fail;
goto FAIL;
}
}
if (status_ != DATA_START_BLOCK) {
error(SD_CARD_ERROR_READ);
goto fail;
goto FAIL;
}
// transfer data
spiRead(dst, count);
@ -503,7 +503,7 @@ bool Sd2Card::readData(uint8_t* dst, uint16_t count) {
recvCrc |= spiRec();
if (calcCrc != recvCrc) {
error(SD_CARD_ERROR_CRC);
goto fail;
goto FAIL;
}
}
#else
@ -515,7 +515,7 @@ bool Sd2Card::readData(uint8_t* dst, uint16_t count) {
// Send an additional dummy byte, required by Toshiba Flash Air SD Card
spiSend(0XFF);
return true;
fail:
FAIL:
chipSelectHigh();
// Send an additional dummy byte, required by Toshiba Flash Air SD Card
spiSend(0XFF);
@ -527,10 +527,10 @@ bool Sd2Card::readRegister(uint8_t cmd, void* buf) {
uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
if (cardCommand(cmd, 0)) {
error(SD_CARD_ERROR_READ_REG);
goto fail;
goto FAIL;
}
return readData(dst, 16);
fail:
FAIL:
chipSelectHigh();
return false;
}
@ -549,11 +549,11 @@ bool Sd2Card::readStart(uint32_t blockNumber) {
if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
if (cardCommand(CMD18, blockNumber)) {
error(SD_CARD_ERROR_CMD18);
goto fail;
goto FAIL;
}
chipSelectHigh();
return true;
fail:
FAIL:
chipSelectHigh();
return false;
}
@ -567,11 +567,11 @@ bool Sd2Card::readStop() {
chipSelectLow();
if (cardCommand(CMD12, 0)) {
error(SD_CARD_ERROR_CMD12);
goto fail;
goto FAIL;
}
chipSelectHigh();
return true;
fail:
FAIL:
chipSelectHigh();
return false;
}
@ -601,10 +601,10 @@ bool Sd2Card::setSckRate(uint8_t sckRateID) {
bool Sd2Card::waitNotBusy(uint16_t timeoutMillis) {
uint16_t t0 = millis();
while (spiRec() != 0XFF) {
if (((uint16_t)millis() - t0) >= timeoutMillis) goto fail;
if (((uint16_t)millis() - t0) >= timeoutMillis) goto FAIL;
}
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -621,23 +621,23 @@ bool Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {
if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
if (cardCommand(CMD24, blockNumber)) {
error(SD_CARD_ERROR_CMD24);
goto fail;
goto FAIL;
}
if (!writeData(DATA_START_BLOCK, src)) goto fail;
if (!writeData(DATA_START_BLOCK, src)) goto FAIL;
// wait for flash programming to complete
if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
error(SD_CARD_ERROR_WRITE_TIMEOUT);
goto fail;
goto FAIL;
}
// response is r2 so get and check two bytes for nonzero
if (cardCommand(CMD13, 0) || spiRec()) {
error(SD_CARD_ERROR_WRITE_PROGRAMMING);
goto fail;
goto FAIL;
}
chipSelectHigh();
return true;
fail:
FAIL:
chipSelectHigh();
return false;
}
@ -650,11 +650,11 @@ fail:
bool Sd2Card::writeData(const uint8_t* src) {
chipSelectLow();
// wait for previous write to finish
if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
if (!writeData(WRITE_MULTIPLE_TOKEN, src)) goto fail;
if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
if (!writeData(WRITE_MULTIPLE_TOKEN, src)) goto FAIL;
chipSelectHigh();
return true;
fail:
FAIL:
error(SD_CARD_ERROR_WRITE_MULTIPLE);
chipSelectHigh();
return false;
@ -670,10 +670,10 @@ bool Sd2Card::writeData(uint8_t token, const uint8_t* src) {
status_ = spiRec();
if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
error(SD_CARD_ERROR_WRITE);
goto fail;
goto FAIL;
}
return true;
fail:
FAIL:
chipSelectHigh();
return false;
}
@ -693,17 +693,17 @@ bool Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) {
// send pre-erase count
if (cardAcmd(ACMD23, eraseCount)) {
error(SD_CARD_ERROR_ACMD23);
goto fail;
goto FAIL;
}
// use address if not SDHC card
if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
if (cardCommand(CMD25, blockNumber)) {
error(SD_CARD_ERROR_CMD25);
goto fail;
goto FAIL;
}
chipSelectHigh();
return true;
fail:
FAIL:
chipSelectHigh();
return false;
}
@ -715,12 +715,12 @@ fail:
*/
bool Sd2Card::writeStop() {
chipSelectLow();
if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
spiSend(STOP_TRAN_TOKEN);
if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
chipSelectHigh();
return true;
fail:
FAIL:
error(SD_CARD_ERROR_STOP_TRAN);
chipSelectHigh();
return false;

22
Marlin/Sd2Card.h
View File

@ -92,27 +92,27 @@ uint8_t const SD_CARD_ERROR_ERASE_TIMEOUT = 0XE;
/** card returned an error token instead of read data */
uint8_t const SD_CARD_ERROR_READ = 0XF;
/** read CID or CSD failed */
uint8_t const SD_CARD_ERROR_READ_REG = 0X10;
uint8_t const SD_CARD_ERROR_READ_REG = 0x10;
/** timeout while waiting for start of read data */
uint8_t const SD_CARD_ERROR_READ_TIMEOUT = 0X11;
uint8_t const SD_CARD_ERROR_READ_TIMEOUT = 0x11;
/** card did not accept STOP_TRAN_TOKEN */
uint8_t const SD_CARD_ERROR_STOP_TRAN = 0X12;
uint8_t const SD_CARD_ERROR_STOP_TRAN = 0x12;
/** card returned an error token as a response to a write operation */
uint8_t const SD_CARD_ERROR_WRITE = 0X13;
uint8_t const SD_CARD_ERROR_WRITE = 0x13;
/** attempt to write protected block zero */
uint8_t const SD_CARD_ERROR_WRITE_BLOCK_ZERO = 0X14; // REMOVE - not used
uint8_t const SD_CARD_ERROR_WRITE_BLOCK_ZERO = 0x14; // REMOVE - not used
/** card did not go ready for a multiple block write */
uint8_t const SD_CARD_ERROR_WRITE_MULTIPLE = 0X15;
uint8_t const SD_CARD_ERROR_WRITE_MULTIPLE = 0x15;
/** card returned an error to a CMD13 status check after a write */
uint8_t const SD_CARD_ERROR_WRITE_PROGRAMMING = 0X16;
uint8_t const SD_CARD_ERROR_WRITE_PROGRAMMING = 0x16;
/** timeout occurred during write programming */
uint8_t const SD_CARD_ERROR_WRITE_TIMEOUT = 0X17;
uint8_t const SD_CARD_ERROR_WRITE_TIMEOUT = 0x17;
/** incorrect rate selected */
uint8_t const SD_CARD_ERROR_SCK_RATE = 0X18;
uint8_t const SD_CARD_ERROR_SCK_RATE = 0x18;
/** init() not called */
uint8_t const SD_CARD_ERROR_INIT_NOT_CALLED = 0X19;
uint8_t const SD_CARD_ERROR_INIT_NOT_CALLED = 0x19;
/** crc check error */
uint8_t const SD_CARD_ERROR_CRC = 0X20;
uint8_t const SD_CARD_ERROR_CRC = 0x20;
//------------------------------------------------------------------------------
// card types
/** Standard capacity V1 SD card */

300
Marlin/SdBaseFile.cpp
View File

@ -39,7 +39,7 @@ void (*SdBaseFile::dateTime_)(uint16_t* date, uint16_t* time) = 0;
//------------------------------------------------------------------------------
// add a cluster to a file
bool SdBaseFile::addCluster() {
if (!vol_->allocContiguous(1, &curCluster_)) goto fail;
if (!vol_->allocContiguous(1, &curCluster_)) goto FAIL;
// if first cluster of file link to directory entry
if (firstCluster_ == 0) {
@ -48,7 +48,7 @@ bool SdBaseFile::addCluster() {
}
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -57,10 +57,10 @@ bool SdBaseFile::addCluster() {
bool SdBaseFile::addDirCluster() {
uint32_t block;
// max folder size
if (fileSize_ / sizeof(dir_t) >= 0XFFFF) goto fail;
if (fileSize_ / sizeof(dir_t) >= 0xFFFF) goto FAIL;
if (!addCluster()) goto fail;
if (!vol_->cacheFlush()) goto fail;
if (!addCluster()) goto FAIL;
if (!vol_->cacheFlush()) goto FAIL;
block = vol_->clusterStartBlock(curCluster_);
@ -72,21 +72,21 @@ bool SdBaseFile::addDirCluster() {
// zero rest of cluster
for (uint8_t i = 1; i < vol_->blocksPerCluster_; i++) {
if (!vol_->writeBlock(block + i, vol_->cacheBuffer_.data)) goto fail;
if (!vol_->writeBlock(block + i, vol_->cacheBuffer_.data)) goto FAIL;
}
// Increase directory file size by cluster size
fileSize_ += 512UL << vol_->clusterSizeShift_;
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
// cache a file's directory entry
// return pointer to cached entry or null for failure
dir_t* SdBaseFile::cacheDirEntry(uint8_t action) {
if (!vol_->cacheRawBlock(dirBlock_, action)) goto fail;
if (!vol_->cacheRawBlock(dirBlock_, action)) goto FAIL;
return vol_->cache()->dir + dirIndex_;
fail:
FAIL:
return 0;
}
//------------------------------------------------------------------------------
@ -115,16 +115,16 @@ bool SdBaseFile::close() {
*/
bool SdBaseFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
// error if no blocks
if (firstCluster_ == 0) goto fail;
if (firstCluster_ == 0) goto FAIL;
for (uint32_t c = firstCluster_; ; c++) {
uint32_t next;
if (!vol_->fatGet(c, &next)) goto fail;
if (!vol_->fatGet(c, &next)) goto FAIL;
// check for contiguous
if (next != (c + 1)) {
// error if not end of chain
if (!vol_->isEOC(next)) goto fail;
if (!vol_->isEOC(next)) goto FAIL;
*bgnBlock = vol_->clusterStartBlock(firstCluster_);
*endBlock = vol_->clusterStartBlock(c)
+ vol_->blocksPerCluster_ - 1;
@ -132,7 +132,7 @@ bool SdBaseFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
}
}
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -157,8 +157,8 @@ bool SdBaseFile::createContiguous(SdBaseFile* dirFile,
const char* path, uint32_t size) {
uint32_t count;
// don't allow zero length file
if (size == 0) goto fail;
if (!open(dirFile, path, O_CREAT | O_EXCL | O_RDWR)) goto fail;
if (size == 0) goto FAIL;
if (!open(dirFile, path, O_CREAT | O_EXCL | O_RDWR)) goto FAIL;
// calculate number of clusters needed
count = ((size - 1) >> (vol_->clusterSizeShift_ + 9)) + 1;
@ -166,7 +166,7 @@ bool SdBaseFile::createContiguous(SdBaseFile* dirFile,
// allocate clusters
if (!vol_->allocContiguous(count, &firstCluster_)) {
remove();
goto fail;
goto FAIL;
}
fileSize_ = size;
@ -174,7 +174,7 @@ bool SdBaseFile::createContiguous(SdBaseFile* dirFile,
flags_ |= F_FILE_DIR_DIRTY;
return sync();
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -188,16 +188,16 @@ fail:
bool SdBaseFile::dirEntry(dir_t* dir) {
dir_t* p;
// make sure fields on SD are correct
if (!sync()) goto fail;
if (!sync()) goto FAIL;
// read entry
p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
if (!p) goto fail;
if (!p) goto FAIL;
// copy to caller's struct
memcpy(dir, p, sizeof(dir_t));
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -395,7 +395,7 @@ bool SdBaseFile::make83Name(const char* str, uint8_t* name, const char** ptr) {
while (*str != '\0' && *str != '/') {
c = *str++;
if (c == '.') {
if (n == 10) goto fail; // only one dot allowed
if (n == 10) goto FAIL; // only one dot allowed
n = 10; // max index for full 8.3 name
i = 8; // place for extension
}
@ -403,9 +403,9 @@ bool SdBaseFile::make83Name(const char* str, uint8_t* name, const char** ptr) {
// illegal FAT characters
PGM_P p = PSTR("|<>^+=?/[];,*\"\\");
uint8_t b;
while ((b = pgm_read_byte(p++))) if (b == c) goto fail;
while ((b = pgm_read_byte(p++))) if (b == c) goto FAIL;
// check size and only allow ASCII printable characters
if (i > n || c < 0x21 || c == 0x7F) goto fail;
if (i > n || c < 0x21 || c == 0x7F) goto FAIL;
// only upper case allowed in 8.3 names - convert lower to upper
name[i++] = (c < 'a' || c > 'z') ? (c) : (c + ('A' - 'a'));
}
@ -413,7 +413,7 @@ bool SdBaseFile::make83Name(const char* str, uint8_t* name, const char** ptr) {
*ptr = str;
// must have a file name, extension is optional
return name[0] != ' ';
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -437,22 +437,22 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const char* path, bool pFlag) {
SdBaseFile* sub = &dir1;
SdBaseFile* start = parent;
if (!parent || isOpen()) goto fail;
if (!parent || isOpen()) goto FAIL;
if (*path == '/') {
while (*path == '/') path++;
if (!parent->isRoot()) {
if (!dir2.openRoot(parent->vol_)) goto fail;
if (!dir2.openRoot(parent->vol_)) goto FAIL;
parent = &dir2;
}
}
while (1) {
if (!make83Name(path, dname, &path)) goto fail;
if (!make83Name(path, dname, &path)) goto FAIL;
while (*path == '/') path++;
if (!*path) break;
if (!sub->open(parent, dname, O_READ)) {
if (!pFlag || !sub->mkdir(parent, dname)) {
goto fail;
goto FAIL;
}
}
if (parent != start) parent->close();
@ -460,7 +460,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const char* path, bool pFlag) {
sub = parent != &dir1 ? &dir1 : &dir2;
}
return mkdir(parent, dname);
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -469,24 +469,24 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
dir_t d;
dir_t* p;
if (!parent->isDir()) goto fail;
if (!parent->isDir()) goto FAIL;
// create a normal file
if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR)) goto fail;
if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR)) goto FAIL;
// convert file to directory
flags_ = O_READ;
type_ = FAT_FILE_TYPE_SUBDIR;
// allocate and zero first cluster
if (!addDirCluster())goto fail;
if (!addDirCluster())goto FAIL;
// force entry to SD
if (!sync()) goto fail;
if (!sync()) goto FAIL;
// cache entry - should already be in cache due to sync() call
p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!p) goto fail;
if (!p) goto FAIL;
// change directory entry attribute
p->attributes = DIR_ATT_DIRECTORY;
@ -498,7 +498,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
// cache block for '.' and '..'
block = vol_->clusterStartBlock(firstCluster_);
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto fail;
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto FAIL;
// copy '.' to block
memcpy(&vol_->cache()->dir[0], &d, sizeof(d));
@ -510,7 +510,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
d.firstClusterHigh = 0;
}
else {
d.firstClusterLow = parent->firstCluster_ & 0XFFFF;
d.firstClusterLow = parent->firstCluster_ & 0xFFFF;
d.firstClusterHigh = parent->firstCluster_ >> 16;
}
// copy '..' to block
@ -518,7 +518,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
// write first block
return vol_->cacheFlush();
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -592,29 +592,29 @@ bool SdBaseFile::open(SdBaseFile* dirFile, const char* path, uint8_t oflag) {
SdBaseFile* parent = dirFile;
SdBaseFile* sub = &dir1;
if (!dirFile) goto fail;
if (!dirFile) goto FAIL;
// error if already open
if (isOpen()) goto fail;
if (isOpen()) goto FAIL;
if (*path == '/') {
while (*path == '/') path++;
if (!dirFile->isRoot()) {
if (!dir2.openRoot(dirFile->vol_)) goto fail;
if (!dir2.openRoot(dirFile->vol_)) goto FAIL;
parent = &dir2;
}
}
while (1) {
if (!make83Name(path, dname, &path)) goto fail;
if (!make83Name(path, dname, &path)) goto FAIL;
while (*path == '/') path++;
if (!*path) break;
if (!sub->open(parent, dname, O_READ)) goto fail;
if (!sub->open(parent, dname, O_READ)) goto FAIL;
if (parent != dirFile) parent->close();
parent = sub;
sub = parent != &dir1 ? &dir1 : &dir2;
}
return open(parent, dname, oflag);
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -634,7 +634,7 @@ bool SdBaseFile::open(SdBaseFile* dirFile,
while (dirFile->curPosition_ < dirFile->fileSize_) {
index = 0XF & (dirFile->curPosition_ >> 5);
p = dirFile->readDirCache();
if (!p) goto fail;
if (!p) goto FAIL;
if (p->name[0] == DIR_NAME_FREE || p->name[0] == DIR_NAME_DELETED) {
// remember first empty slot
@ -653,21 +653,21 @@ bool SdBaseFile::open(SdBaseFile* dirFile,
}
if (fileFound) {
// don't open existing file if O_EXCL
if (oflag & O_EXCL) goto fail;
if (oflag & O_EXCL) goto FAIL;
}
else {
// don't create unless O_CREAT and O_WRITE
if (!(oflag & O_CREAT) || !(oflag & O_WRITE)) goto fail;
if (!(oflag & O_CREAT) || !(oflag & O_WRITE)) goto FAIL;
if (emptyFound) {
index = dirIndex_;
p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!p) goto fail;
if (!p) goto FAIL;
}
else {
if (dirFile->type_ == FAT_FILE_TYPE_ROOT_FIXED) goto fail;
if (dirFile->type_ == FAT_FILE_TYPE_ROOT_FIXED) goto FAIL;
// add and zero cluster for dirFile - first cluster is in cache for write
if (!dirFile->addDirCluster()) goto fail;
if (!dirFile->addDirCluster()) goto FAIL;
// use first entry in cluster
p = dirFile->vol_->cache()->dir;
@ -692,11 +692,11 @@ bool SdBaseFile::open(SdBaseFile* dirFile,
p->lastWriteTime = p->creationTime;
// write entry to SD
if (!dirFile->vol_->cacheFlush()) goto fail;
if (!dirFile->vol_->cacheFlush()) goto FAIL;
}
// open entry in cache
return openCachedEntry(index, oflag);
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -719,26 +719,26 @@ bool SdBaseFile::open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag) {
vol_ = dirFile->vol_;
// error if already open
if (isOpen() || !dirFile) goto fail;
if (isOpen() || !dirFile) goto FAIL;
// don't open existing file if O_EXCL - user call error
if (oflag & O_EXCL) goto fail;
if (oflag & O_EXCL) goto FAIL;
// seek to location of entry
if (!dirFile->seekSet(32 * index)) goto fail;
if (!dirFile->seekSet(32 * index)) goto FAIL;
// read entry into cache
p = dirFile->readDirCache();
if (!p) goto fail;
if (!p) goto FAIL;
// error if empty slot or '.' or '..'
if (p->name[0] == DIR_NAME_FREE ||
p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
goto fail;
goto FAIL;
}
// open cached entry
return openCachedEntry(index & 0XF, oflag);
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -749,7 +749,7 @@ bool SdBaseFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
// write or truncate is an error for a directory or read-only file
if (p->attributes & (DIR_ATT_READ_ONLY | DIR_ATT_DIRECTORY)) {
if (oflag & (O_WRITE | O_TRUNC)) goto fail;
if (oflag & (O_WRITE | O_TRUNC)) goto FAIL;
}
// remember location of directory entry on SD
dirBlock_ = vol_->cacheBlockNumber();
@ -765,11 +765,11 @@ bool SdBaseFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
type_ = FAT_FILE_TYPE_NORMAL;
}
else if (DIR_IS_SUBDIR(p)) {
if (!vol_->chainSize(firstCluster_, &fileSize_)) goto fail;
if (!vol_->chainSize(firstCluster_, &fileSize_)) goto FAIL;
type_ = FAT_FILE_TYPE_SUBDIR;
}
else {
goto fail;
goto FAIL;
}
// save open flags for read/write
flags_ = oflag & F_OFLAG;
@ -779,7 +779,7 @@ bool SdBaseFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
curPosition_ = 0;
if ((oflag & O_TRUNC) && !truncate(0)) return false;
return oflag & O_AT_END ? seekEnd(0) : true;
fail:
FAIL:
type_ = FAT_FILE_TYPE_CLOSED;
return false;
}
@ -799,10 +799,10 @@ bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
dir_t* p;
uint8_t index;
if (!dirFile) goto fail;
if (!dirFile) goto FAIL;
// error if already open
if (isOpen()) goto fail;
if (isOpen()) goto FAIL;
vol_ = dirFile->vol_;
@ -811,10 +811,10 @@ bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
// read entry into cache
p = dirFile->readDirCache();
if (!p) goto fail;
if (!p) goto FAIL;
// done if last entry
if (p->name[0] == DIR_NAME_FREE) goto fail;
if (p->name[0] == DIR_NAME_FREE) goto FAIL;
// skip empty slot or '.' or '..'
if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
@ -825,7 +825,7 @@ bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
return openCachedEntry(index, oflag);
}
}
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -844,14 +844,14 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
uint32_t cluster;
uint32_t lbn;
// error if already open or dir is root or dir is not a directory
if (isOpen() || !dir || dir->isRoot() || !dir->isDir()) goto fail;
if (isOpen() || !dir || dir->isRoot() || !dir->isDir()) goto FAIL;
vol_ = dir->vol_;
// position to '..'
if (!dir->seekSet(32)) goto fail;
if (!dir->seekSet(32)) goto FAIL;
// read '..' entry
if (dir->read(&entry, sizeof(entry)) != 32) goto fail;
if (dir->read(&entry, sizeof(entry)) != 32) goto FAIL;
// verify it is '..'
if (entry.name[0] != '.' || entry.name[1] != '.') goto fail;
if (entry.name[0] != '.' || entry.name[1] != '.') goto FAIL;
// start cluster for '..'
cluster = entry.firstClusterLow;
cluster |= (uint32_t)entry.firstClusterHigh << 16;
@ -860,27 +860,27 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
lbn = vol_->clusterStartBlock(cluster);
// first block of parent dir
if (!vol_->cacheRawBlock(lbn, SdVolume::CACHE_FOR_READ)) {
goto fail;
goto FAIL;
}
p = &vol_->cacheBuffer_.dir[1];
// verify name for '../..'
if (p->name[0] != '.' || p->name[1] != '.') goto fail;
if (p->name[0] != '.' || p->name[1] != '.') goto FAIL;
// '..' is pointer to first cluster of parent. open '../..' to find parent
if (p->firstClusterHigh == 0 && p->firstClusterLow == 0) {
if (!file.openRoot(dir->volume())) goto fail;
if (!file.openRoot(dir->volume())) goto FAIL;
}
else if (!file.openCachedEntry(1, O_READ)) {
goto fail;
goto FAIL;
}
// search for parent in '../..'
do {
if (file.readDir(&entry, NULL) != 32) goto fail;
if (file.readDir(&entry, NULL) != 32) goto FAIL;
c = entry.firstClusterLow;
c |= (uint32_t)entry.firstClusterHigh << 16;
} while (c != cluster);
// open parent
return open(&file, file.curPosition() / 32 - 1, O_READ);
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -895,7 +895,7 @@ fail:
*/
bool SdBaseFile::openRoot(SdVolume* vol) {
// error if file is already open
if (isOpen()) goto fail;
if (isOpen()) goto FAIL;
if (vol->fatType() == 16 || (FAT12_SUPPORT && vol->fatType() == 12)) {
type_ = FAT_FILE_TYPE_ROOT_FIXED;
@ -905,7 +905,7 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
else if (vol->fatType() == 32) {
type_ = FAT_FILE_TYPE_ROOT32;
firstCluster_ = vol->rootDirStart();
if (!vol->chainSize(firstCluster_, &fileSize_)) goto fail;
if (!vol->chainSize(firstCluster_, &fileSize_)) goto FAIL;
}
else {
// volume is not initialized, invalid, or FAT12 without support
@ -923,7 +923,7 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
dirBlock_ = 0;
dirIndex_ = 0;
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1055,7 +1055,7 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
uint32_t block; // raw device block number
// error if not open or write only
if (!isOpen() || !(flags_ & O_READ)) goto fail;
if (!isOpen() || !(flags_ & O_READ)) goto FAIL;
// max bytes left in file
NOMORE(nbyte, fileSize_ - curPosition_);
@ -1063,7 +1063,7 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
// amount left to read
toRead = nbyte;
while (toRead > 0) {
offset = curPosition_ & 0X1FF; // offset in block
offset = curPosition_ & 0x1FF; // offset in block
if (type_ == FAT_FILE_TYPE_ROOT_FIXED) {
block = vol_->rootDirStart() + (curPosition_ >> 9);
}
@ -1077,7 +1077,7 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
}
else {
// get next cluster from FAT
if (!vol_->fatGet(curCluster_, &curCluster_)) goto fail;
if (!vol_->fatGet(curCluster_, &curCluster_)) goto FAIL;
}
}
block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
@ -1089,11 +1089,11 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
// no buffering needed if n == 512
if (n == 512 && block != vol_->cacheBlockNumber()) {
if (!vol_->readBlock(block, dst)) goto fail;
if (!vol_->readBlock(block, dst)) goto FAIL;
}
else {
// read block to cache and copy data to caller
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) goto fail;
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) goto FAIL;
uint8_t* src = vol_->cache()->data + offset;
memcpy(dst, src, n);
}
@ -1102,7 +1102,7 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
toRead -= n;
}
return nbyte;
fail:
FAIL:
return -1;
}
@ -1120,7 +1120,7 @@ fail:
int8_t SdBaseFile::readDir(dir_t* dir, char* longFilename) {
int16_t n;
// if not a directory file or miss-positioned return an error
if (!isDir() || (0X1F & curPosition_)) return -1;
if (!isDir() || (0x1F & curPosition_)) return -1;
//If we have a longFilename buffer, mark it as invalid. If we find a long filename it will be filled automaticly.
if (longFilename != NULL) longFilename[0] = '\0';
@ -1161,20 +1161,20 @@ int8_t SdBaseFile::readDir(dir_t* dir, char* longFilename) {
dir_t* SdBaseFile::readDirCache() {
uint8_t i;
// error if not directory
if (!isDir()) goto fail;
if (!isDir()) goto FAIL;
// index of entry in cache
i = (curPosition_ >> 5) & 0XF;
// use read to locate and cache block
if (read() < 0) goto fail;
if (read() < 0) goto FAIL;
// advance to next entry
curPosition_ += 31;
// return pointer to entry
return vol_->cache()->dir + i;
fail:
FAIL:
return 0;
}
//------------------------------------------------------------------------------
@ -1194,11 +1194,11 @@ fail:
bool SdBaseFile::remove() {
dir_t* d;
// free any clusters - will fail if read-only or directory
if (!truncate(0)) goto fail;
if (!truncate(0)) goto FAIL;
// cache directory entry
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) goto fail;
if (!d) goto FAIL;
// mark entry deleted
d->name[0] = DIR_NAME_DELETED;
@ -1209,7 +1209,7 @@ bool SdBaseFile::remove() {
// write entry to SD
return vol_->cacheFlush();
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1232,9 +1232,9 @@ fail:
*/
bool SdBaseFile::remove(SdBaseFile* dirFile, const char* path) {
SdBaseFile file;
if (!file.open(dirFile, path, O_WRITE)) goto fail;
if (!file.open(dirFile, path, O_WRITE)) goto FAIL;
return file.remove();
fail:
FAIL:
// can't set iostate - static function
return false;
}
@ -1256,15 +1256,15 @@ bool SdBaseFile::rename(SdBaseFile* dirFile, const char* newPath) {
dir_t* d;
// must be an open file or subdirectory
if (!(isFile() || isSubDir())) goto fail;
if (!(isFile() || isSubDir())) goto FAIL;
// can't move file
if (vol_ != dirFile->vol_) goto fail;
if (vol_ != dirFile->vol_) goto FAIL;
// sync() and cache directory entry
sync();
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) goto fail;
if (!d) goto FAIL;
// save directory entry
memcpy(&entry, d, sizeof(entry));
@ -1295,7 +1295,7 @@ bool SdBaseFile::rename(SdBaseFile* dirFile, const char* newPath) {
// cache new directory entry
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) goto fail;
if (!d) goto FAIL;
// copy all but name field to new directory entry
memcpy(&d->attributes, &entry.attributes, sizeof(entry) - sizeof(d->name));
@ -1304,27 +1304,27 @@ bool SdBaseFile::rename(SdBaseFile* dirFile, const char* newPath) {
if (dirCluster) {
// get new dot dot
uint32_t block = vol_->clusterStartBlock(dirCluster);
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) goto fail;
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) goto FAIL;
memcpy(&entry, &vol_->cache()->dir[1], sizeof(entry));
// free unused cluster
if (!vol_->freeChain(dirCluster)) goto fail;
if (!vol_->freeChain(dirCluster)) goto FAIL;
// store new dot dot
block = vol_->clusterStartBlock(firstCluster_);
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto fail;
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto FAIL;
memcpy(&vol_->cache()->dir[1], &entry, sizeof(entry));
}
return vol_->cacheFlush();
restore:
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) goto fail;
if (!d) goto FAIL;
// restore entry
d->name[0] = entry.name[0];
vol_->cacheFlush();
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1345,26 +1345,26 @@ fail:
*/
bool SdBaseFile::rmdir() {
// must be open subdirectory
if (!isSubDir()) goto fail;
if (!isSubDir()) goto FAIL;
rewind();
// make sure directory is empty
while (curPosition_ < fileSize_) {
dir_t* p = readDirCache();
if (!p) goto fail;
if (!p) goto FAIL;
// done if past last used entry
if (p->name[0] == DIR_NAME_FREE) break;
// skip empty slot, '.' or '..'
if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;
// error not empty
if (DIR_IS_FILE_OR_SUBDIR(p)) goto fail;
if (DIR_IS_FILE_OR_SUBDIR(p)) goto FAIL;
}
// convert empty directory to normal file for remove
type_ = FAT_FILE_TYPE_NORMAL;
flags_ |= O_WRITE;
return remove();
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1392,7 +1392,7 @@ bool SdBaseFile::rmRfStar() {
index = curPosition_ / 32;
dir_t* p = readDirCache();
if (!p) goto fail;
if (!p) goto FAIL;
// done if past last entry
if (p->name[0] == DIR_NAME_FREE) break;
@ -1403,27 +1403,27 @@ bool SdBaseFile::rmRfStar() {
// skip if part of long file name or volume label in root
if (!DIR_IS_FILE_OR_SUBDIR(p)) continue;
if (!f.open(this, index, O_READ)) goto fail;
if (!f.open(this, index, O_READ)) goto FAIL;
if (f.isSubDir()) {
// recursively delete
if (!f.rmRfStar()) goto fail;
if (!f.rmRfStar()) goto FAIL;
}
else {
// ignore read-only
f.flags_ |= O_WRITE;
if (!f.remove()) goto fail;
if (!f.remove()) goto FAIL;
}
// position to next entry if required
if (curPosition_ != (32 * (index + 1))) {
if (!seekSet(32 * (index + 1))) goto fail;
if (!seekSet(32 * (index + 1))) goto FAIL;
}
}
// don't try to delete root
if (!isRoot()) {
if (!rmdir()) goto fail;
if (!rmdir()) goto FAIL;
}
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1451,7 +1451,7 @@ bool SdBaseFile::seekSet(uint32_t pos) {
uint32_t nCur;
uint32_t nNew;
// error if file not open or seek past end of file
if (!isOpen() || pos > fileSize_) goto fail;
if (!isOpen() || pos > fileSize_) goto FAIL;
if (type_ == FAT_FILE_TYPE_ROOT_FIXED) {
curPosition_ = pos;
@ -1476,14 +1476,14 @@ bool SdBaseFile::seekSet(uint32_t pos) {
nNew -= nCur;
}
while (nNew--) {
if (!vol_->fatGet(curCluster_, &curCluster_)) goto fail;
if (!vol_->fatGet(curCluster_, &curCluster_)) goto FAIL;
}
curPosition_ = pos;
done:
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1502,18 +1502,18 @@ void SdBaseFile::setpos(filepos_t* pos) {
*/
bool SdBaseFile::sync() {
// only allow open files and directories
if (!isOpen()) goto fail;
if (!isOpen()) goto FAIL;
if (flags_ & F_FILE_DIR_DIRTY) {
dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
// check for deleted by another open file object
if (!d || d->name[0] == DIR_NAME_DELETED) goto fail;
if (!d || d->name[0] == DIR_NAME_DELETED) goto FAIL;
// do not set filesize for dir files
if (!isDir()) d->fileSize = fileSize_;
// update first cluster fields
d->firstClusterLow = firstCluster_ & 0XFFFF;
d->firstClusterLow = firstCluster_ & 0xFFFF;
d->firstClusterHigh = firstCluster_ >> 16;
// set modify time if user supplied a callback date/time function
@ -1526,7 +1526,7 @@ bool SdBaseFile::sync() {
}
return vol_->cacheFlush();
fail:
FAIL:
writeError = true;
return false;
}
@ -1547,13 +1547,13 @@ bool SdBaseFile::timestamp(SdBaseFile* file) {
dir_t dir;
// get timestamps
if (!file->dirEntry(&dir)) goto fail;
if (!file->dirEntry(&dir)) goto FAIL;
// update directory fields
if (!sync()) goto fail;
if (!sync()) goto FAIL;
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) goto fail;
if (!d) goto FAIL;
// copy timestamps
d->lastAccessDate = dir.lastAccessDate;
@ -1566,7 +1566,7 @@ bool SdBaseFile::timestamp(SdBaseFile* file) {
// write back entry
return vol_->cacheFlush();
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1619,13 +1619,13 @@ bool SdBaseFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
|| hour > 23
|| minute > 59
|| second > 59) {
goto fail;
goto FAIL;
}
// update directory entry
if (!sync()) goto fail;
if (!sync()) goto FAIL;
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) goto fail;
if (!d) goto FAIL;
dirDate = FAT_DATE(year, month, day);
dirTime = FAT_TIME(hour, minute, second);
@ -1643,7 +1643,7 @@ bool SdBaseFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
d->lastWriteTime = dirTime;
}
return vol_->cacheFlush();
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1661,10 +1661,10 @@ fail:
bool SdBaseFile::truncate(uint32_t length) {
uint32_t newPos;
// error if not a normal file or read-only
if (!isFile() || !(flags_ & O_WRITE)) goto fail;
if (!isFile() || !(flags_ & O_WRITE)) goto FAIL;
// error if length is greater than current size
if (length > fileSize_) goto fail;
if (length > fileSize_) goto FAIL;
// fileSize and length are zero - nothing to do
if (fileSize_ == 0) return true;
@ -1673,23 +1673,23 @@ bool SdBaseFile::truncate(uint32_t length) {
newPos = curPosition_ > length ? length : curPosition_;
// position to last cluster in truncated file
if (!seekSet(length)) goto fail;
if (!seekSet(length)) goto FAIL;
if (length == 0) {
// free all clusters
if (!vol_->freeChain(firstCluster_)) goto fail;
if (!vol_->freeChain(firstCluster_)) goto FAIL;
firstCluster_ = 0;
}
else {
uint32_t toFree;
if (!vol_->fatGet(curCluster_, &toFree)) goto fail;
if (!vol_->fatGet(curCluster_, &toFree)) goto FAIL;
if (!vol_->isEOC(toFree)) {
// free extra clusters
if (!vol_->freeChain(toFree)) goto fail;
if (!vol_->freeChain(toFree)) goto FAIL;
// current cluster is end of chain
if (!vol_->fatPutEOC(curCluster_)) goto fail;
if (!vol_->fatPutEOC(curCluster_)) goto FAIL;
}
}
fileSize_ = length;
@ -1697,12 +1697,12 @@ bool SdBaseFile::truncate(uint32_t length) {
// need to update directory entry
flags_ |= F_FILE_DIR_DIRTY;
if (!sync()) goto fail;
if (!sync()) goto FAIL;
// set file to correct position
return seekSet(newPos);
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -1729,22 +1729,22 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
uint16_t nToWrite = nbyte;
// error if not a normal file or is read-only
if (!isFile() || !(flags_ & O_WRITE)) goto fail;
if (!isFile() || !(flags_ & O_WRITE)) goto FAIL;
// seek to end of file if append flag
if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
if (!seekEnd()) goto fail;
if (!seekEnd()) goto FAIL;
}
while (nToWrite > 0) {
uint8_t blockOfCluster = vol_->blockOfCluster(curPosition_);
uint16_t blockOffset = curPosition_ & 0X1FF;
uint16_t blockOffset = curPosition_ & 0x1FF;
if (blockOfCluster == 0 && blockOffset == 0) {
// start of new cluster
if (curCluster_ == 0) {
if (firstCluster_ == 0) {
// allocate first cluster of file
if (!addCluster()) goto fail;
if (!addCluster()) goto FAIL;
}
else {
curCluster_ = firstCluster_;
@ -1752,10 +1752,10 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
}
else {
uint32_t next;
if (!vol_->fatGet(curCluster_, &next)) goto fail;
if (!vol_->fatGet(curCluster_, &next)) goto FAIL;
if (vol_->isEOC(next)) {
// add cluster if at end of chain
if (!addCluster()) goto fail;
if (!addCluster()) goto FAIL;
}
else {
curCluster_ = next;
@ -1774,20 +1774,20 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
// full block - don't need to use cache
if (vol_->cacheBlockNumber() == block) {
// invalidate cache if block is in cache
vol_->cacheSetBlockNumber(0XFFFFFFFF, false);
vol_->cacheSetBlockNumber(0xFFFFFFFF, false);
}
if (!vol_->writeBlock(block, src)) goto fail;
if (!vol_->writeBlock(block, src)) goto FAIL;
}
else {
if (blockOffset == 0 && curPosition_ >= fileSize_) {
// start of new block don't need to read into cache
if (!vol_->cacheFlush()) goto fail;
if (!vol_->cacheFlush()) goto FAIL;
// set cache dirty and SD address of block
vol_->cacheSetBlockNumber(block, true);
}
else {
// rewrite part of block
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto fail;
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto FAIL;
}
uint8_t* dst = vol_->cache()->data + blockOffset;
memcpy(dst, src, n);
@ -1807,11 +1807,11 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
}
if (flags_ & O_SYNC) {
if (!sync()) goto fail;
if (!sync()) goto FAIL;
}
return nbyte;
fail:
FAIL:
// return for write error
writeError = true;
return -1;

26
Marlin/SdBaseFile.h
View File

@ -54,11 +54,11 @@ struct filepos_t {
// use the gnu style oflag in open()
/** open() oflag for reading */
uint8_t const O_READ = 0X01;
uint8_t const O_READ = 0x01;
/** open() oflag - same as O_IN */
uint8_t const O_RDONLY = O_READ;
/** open() oflag for write */
uint8_t const O_WRITE = 0X02;
uint8_t const O_WRITE = 0x02;
/** open() oflag - same as O_WRITE */
uint8_t const O_WRONLY = O_WRITE;
/** open() oflag for reading and writing */
@ -66,17 +66,17 @@ uint8_t const O_RDWR = (O_READ | O_WRITE);
/** open() oflag mask for access modes */
uint8_t const O_ACCMODE = (O_READ | O_WRITE);
/** The file offset shall be set to the end of the file prior to each write. */
uint8_t const O_APPEND = 0X04;
uint8_t const O_APPEND = 0x04;
/** synchronous writes - call sync() after each write */
uint8_t const O_SYNC = 0X08;
uint8_t const O_SYNC = 0x08;
/** truncate the file to zero length */
uint8_t const O_TRUNC = 0X10;
uint8_t const O_TRUNC = 0x10;
/** set the initial position at the end of the file */
uint8_t const O_AT_END = 0X20;
uint8_t const O_AT_END = 0x20;
/** create the file if nonexistent */
uint8_t const O_CREAT = 0X40;
uint8_t const O_CREAT = 0x40;
/** If O_CREAT and O_EXCL are set, open() shall fail if the file exists */
uint8_t const O_EXCL = 0X80;
uint8_t const O_EXCL = 0x80;
// SdBaseFile class static and const definitions
// flags for ls()
@ -141,7 +141,7 @@ static inline uint8_t FAT_MONTH(uint16_t fatDate) {
* \return Extracted day [1,31]
*/
static inline uint8_t FAT_DAY(uint16_t fatDate) {
return fatDate & 0X1F;
return fatDate & 0x1F;
}
/** time field for FAT directory entry
* \param[in] hour [0,23]
@ -167,7 +167,7 @@ static inline uint8_t FAT_HOUR(uint16_t fatTime) {
* \return Extracted minute [0,59]
*/
static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
return (fatTime >> 5) & 0X3F;
return (fatTime >> 5) & 0x3F;
}
/** second part of FAT directory time field
* Note second/2 is stored in packed time.
@ -177,7 +177,7 @@ static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
* \return Extracted second [0,58]
*/
static inline uint8_t FAT_SECOND(uint16_t fatTime) {
return 2 * (fatTime & 0X1F);
return 2 * (fatTime & 0x1F);
}
/** Default date for file timestamps is 1 Jan 2000 */
uint16_t const FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;
@ -338,10 +338,10 @@ class SdBaseFile {
// data time callback function
static void (*dateTime_)(uint16_t* date, uint16_t* time);
// bits defined in flags_
// should be 0X0F
// should be 0x0F
static uint8_t const F_OFLAG = (O_ACCMODE | O_APPEND | O_SYNC);
// sync of directory entry required
static uint8_t const F_FILE_DIR_DIRTY = 0X80;
static uint8_t const F_FILE_DIR_DIRTY = 0x80;
// private data
uint8_t flags_; // See above for definition of flags_ bits

72
Marlin/SdFatStructs.h
View File

@ -43,11 +43,11 @@
*/
//------------------------------------------------------------------------------
/** Value for byte 510 of boot block or MBR */
uint8_t const BOOTSIG0 = 0X55;
uint8_t const BOOTSIG0 = 0x55;
/** Value for byte 511 of boot block or MBR */
uint8_t const BOOTSIG1 = 0XAA;
uint8_t const BOOTSIG1 = 0xAA;
/** Value for bootSignature field int FAT/FAT32 boot sector */
uint8_t const EXTENDED_BOOT_SIG = 0X29;
uint8_t const EXTENDED_BOOT_SIG = 0x29;
//------------------------------------------------------------------------------
/**
* \struct partitionTable
@ -59,8 +59,8 @@ uint8_t const EXTENDED_BOOT_SIG = 0X29;
struct partitionTable {
/**
* Boot Indicator . Indicates whether the volume is the active
* partition. Legal values include: 0X00. Do not use for booting.
* 0X80 Active partition.
* partition. Legal values include: 0x00. Do not use for booting.
* 0x80 Active partition.
*/
uint8_t boot;
/**
@ -126,9 +126,9 @@ struct masterBootRecord {
uint16_t usuallyZero;
/** Partition tables. */
part_t part[4];
/** First MBR signature byte. Must be 0X55 */
/** First MBR signature byte. Must be 0x55 */
uint8_t mbrSig0;
/** Second MBR signature byte. Must be 0XAA */
/** Second MBR signature byte. Must be 0xAA */
uint8_t mbrSig1;
} PACKED;
/** Type name for masterBootRecord */
@ -234,7 +234,7 @@ struct fat_boot {
uint8_t driveNumber;
/** used by Windows NT - should be zero for FAT */
uint8_t reserved1;
/** 0X29 if next three fields are valid */
/** 0x29 if next three fields are valid */
uint8_t bootSignature;
/**
* A random serial number created when formatting a disk,
@ -254,9 +254,9 @@ struct fat_boot {
char fileSystemType[8];
/** X86 boot code */
uint8_t bootCode[448];
/** must be 0X55 */
/** must be 0x55 */
uint8_t bootSectorSig0;
/** must be 0XAA */
/** must be 0xAA */
uint8_t bootSectorSig1;
} PACKED;
/** Type name for FAT Boot Sector */
@ -389,7 +389,7 @@ struct fat32_boot {
uint8_t driveNumber;
/** used by Windows NT - should be zero for FAT */
uint8_t reserved1;
/** 0X29 if next three fields are valid */
/** 0x29 if next three fields are valid */
uint8_t bootSignature;
/**
* A random serial number created when formatting a disk,
@ -408,9 +408,9 @@ struct fat32_boot {
char fileSystemType[8];
/** X86 boot code */
uint8_t bootCode[420];
/** must be 0X55 */
/** must be 0x55 */
uint8_t bootSectorSig0;
/** must be 0XAA */
/** must be 0xAA */
uint8_t bootSectorSig1;
} PACKED;
/** Type name for FAT32 Boot Sector */
@ -427,11 +427,11 @@ uint32_t const FSINFO_STRUCT_SIG = 0x61417272;
*
*/
struct fat32_fsinfo {
/** must be 0X52, 0X52, 0X61, 0X41 */
/** must be 0x52, 0x52, 0x61, 0x41 */
uint32_t leadSignature;
/** must be zero */
uint8_t reserved1[480];
/** must be 0X72, 0X72, 0X41, 0X61 */
/** must be 0x72, 0x72, 0x41, 0x61 */
uint32_t structSignature;
/**
* Contains the last known free cluster count on the volume.
@ -450,7 +450,7 @@ struct fat32_fsinfo {
uint32_t nextFree;
/** must be zero */
uint8_t reserved2[12];
/** must be 0X00, 0X00, 0X55, 0XAA */
/** must be 0x00, 0x00, 0x55, 0xAA */
uint8_t tailSignature[4];
} PACKED;
/** Type name for FAT32 FSINFO Sector */
@ -458,19 +458,19 @@ typedef struct fat32_fsinfo fat32_fsinfo_t;
//------------------------------------------------------------------------------
// End Of Chain values for FAT entries
/** FAT12 end of chain value used by Microsoft. */
uint16_t const FAT12EOC = 0XFFF;
uint16_t const FAT12EOC = 0xFFF;
/** Minimum value for FAT12 EOC. Use to test for EOC. */
uint16_t const FAT12EOC_MIN = 0XFF8;
uint16_t const FAT12EOC_MIN = 0xFF8;
/** FAT16 end of chain value used by Microsoft. */
uint16_t const FAT16EOC = 0XFFFF;
uint16_t const FAT16EOC = 0xFFFF;
/** Minimum value for FAT16 EOC. Use to test for EOC. */
uint16_t const FAT16EOC_MIN = 0XFFF8;
uint16_t const FAT16EOC_MIN = 0xFFF8;
/** FAT32 end of chain value used by Microsoft. */
uint32_t const FAT32EOC = 0X0FFFFFFF;
uint32_t const FAT32EOC = 0x0FFFFFFF;
/** Minimum value for FAT32 EOC. Use to test for EOC. */
uint32_t const FAT32EOC_MIN = 0X0FFFFFF8;
uint32_t const FAT32EOC_MIN = 0x0FFFFFF8;
/** Mask a for FAT32 entry. Entries are 28 bits. */
uint32_t const FAT32MASK = 0X0FFFFFFF;
uint32_t const FAT32MASK = 0x0FFFFFFF;
//------------------------------------------------------------------------------
/**
* \struct directoryEntry
@ -590,31 +590,31 @@ struct directoryVFATEntry {
typedef struct directoryEntry dir_t;
/** Type name for directoryVFATEntry */
typedef struct directoryVFATEntry vfat_t;
/** escape for name[0] = 0XE5 */
uint8_t const DIR_NAME_0XE5 = 0X05;
/** escape for name[0] = 0xE5 */
uint8_t const DIR_NAME_0xE5 = 0x05;
/** name[0] value for entry that is free after being "deleted" */
uint8_t const DIR_NAME_DELETED = 0XE5;
uint8_t const DIR_NAME_DELETED = 0xE5;
/** name[0] value for entry that is free and no allocated entries follow */
uint8_t const DIR_NAME_FREE = 0X00;
uint8_t const DIR_NAME_FREE = 0x00;
/** file is read-only */
uint8_t const DIR_ATT_READ_ONLY = 0X01;
uint8_t const DIR_ATT_READ_ONLY = 0x01;
/** File should hidden in directory listings */
uint8_t const DIR_ATT_HIDDEN = 0X02;
uint8_t const DIR_ATT_HIDDEN = 0x02;
/** Entry is for a system file */
uint8_t const DIR_ATT_SYSTEM = 0X04;
uint8_t const DIR_ATT_SYSTEM = 0x04;
/** Directory entry contains the volume label */
uint8_t const DIR_ATT_VOLUME_ID = 0X08;
uint8_t const DIR_ATT_VOLUME_ID = 0x08;
/** Entry is for a directory */
uint8_t const DIR_ATT_DIRECTORY = 0X10;
uint8_t const DIR_ATT_DIRECTORY = 0x10;
/** Old DOS archive bit for backup support */
uint8_t const DIR_ATT_ARCHIVE = 0X20;
uint8_t const DIR_ATT_ARCHIVE = 0x20;
/** Test value for long name entry. Test is
(d->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME. */
uint8_t const DIR_ATT_LONG_NAME = 0X0F;
uint8_t const DIR_ATT_LONG_NAME = 0x0F;
/** Test mask for long name entry */
uint8_t const DIR_ATT_LONG_NAME_MASK = 0X3F;
uint8_t const DIR_ATT_LONG_NAME_MASK = 0x3F;
/** defined attribute bits */
uint8_t const DIR_ATT_DEFINED_BITS = 0X3F;
uint8_t const DIR_ATT_DEFINED_BITS = 0x3F;
/** Directory entry is part of a long name
* \param[in] dir Pointer to a directory entry.
*

52
Marlin/SdInfo.h
View File

@ -45,59 +45,59 @@
//------------------------------------------------------------------------------
// SD card commands
/** GO_IDLE_STATE - init card in spi mode if CS low */
uint8_t const CMD0 = 0X00;
uint8_t const CMD0 = 0x00;
/** SEND_IF_COND - verify SD Memory Card interface operating condition.*/
uint8_t const CMD8 = 0X08;
uint8_t const CMD8 = 0x08;
/** SEND_CSD - read the Card Specific Data (CSD register) */
uint8_t const CMD9 = 0X09;
uint8_t const CMD9 = 0x09;
/** SEND_CID - read the card identification information (CID register) */
uint8_t const CMD10 = 0X0A;
uint8_t const CMD10 = 0x0A;
/** STOP_TRANSMISSION - end multiple block read sequence */
uint8_t const CMD12 = 0X0C;
uint8_t const CMD12 = 0x0C;
/** SEND_STATUS - read the card status register */
uint8_t const CMD13 = 0X0D;
uint8_t const CMD13 = 0x0D;
/** READ_SINGLE_BLOCK - read a single data block from the card */
uint8_t const CMD17 = 0X11;
uint8_t const CMD17 = 0x11;
/** READ_MULTIPLE_BLOCK - read a multiple data blocks from the card */
uint8_t const CMD18 = 0X12;
uint8_t const CMD18 = 0x12;
/** WRITE_BLOCK - write a single data block to the card */
uint8_t const CMD24 = 0X18;
uint8_t const CMD24 = 0x18;
/** WRITE_MULTIPLE_BLOCK - write blocks of data until a STOP_TRANSMISSION */
uint8_t const CMD25 = 0X19;
uint8_t const CMD25 = 0x19;
/** ERASE_WR_BLK_START - sets the address of the first block to be erased */
uint8_t const CMD32 = 0X20;
uint8_t const CMD32 = 0x20;
/** ERASE_WR_BLK_END - sets the address of the last block of the continuous
range to be erased*/
uint8_t const CMD33 = 0X21;
uint8_t const CMD33 = 0x21;
/** ERASE - erase all previously selected blocks */
uint8_t const CMD38 = 0X26;
uint8_t const CMD38 = 0x26;
/** APP_CMD - escape for application specific command */
uint8_t const CMD55 = 0X37;
uint8_t const CMD55 = 0x37;
/** READ_OCR - read the OCR register of a card */
uint8_t const CMD58 = 0X3A;
uint8_t const CMD58 = 0x3A;
/** SET_WR_BLK_ERASE_COUNT - Set the number of write blocks to be
pre-erased before writing */
uint8_t const ACMD23 = 0X17;
uint8_t const ACMD23 = 0x17;
/** SD_SEND_OP_COMD - Sends host capacity support information and
activates the card's initialization process */
uint8_t const ACMD41 = 0X29;
uint8_t const ACMD41 = 0x29;
//------------------------------------------------------------------------------
/** status for card in the ready state */
uint8_t const R1_READY_STATE = 0X00;
uint8_t const R1_READY_STATE = 0x00;
/** status for card in the idle state */
uint8_t const R1_IDLE_STATE = 0X01;
uint8_t const R1_IDLE_STATE = 0x01;
/** status bit for illegal command */
uint8_t const R1_ILLEGAL_COMMAND = 0X04;
uint8_t const R1_ILLEGAL_COMMAND = 0x04;
/** start data token for read or write single block*/
uint8_t const DATA_START_BLOCK = 0XFE;
uint8_t const DATA_START_BLOCK = 0xFE;
/** stop token for write multiple blocks*/
uint8_t const STOP_TRAN_TOKEN = 0XFD;
uint8_t const STOP_TRAN_TOKEN = 0xFD;
/** start data token for write multiple blocks*/
uint8_t const WRITE_MULTIPLE_TOKEN = 0XFC;
uint8_t const WRITE_MULTIPLE_TOKEN = 0xFC;
/** mask for data response tokens after a write block operation */
uint8_t const DATA_RES_MASK = 0X1F;
uint8_t const DATA_RES_MASK = 0x1F;
/** write data accepted token */
uint8_t const DATA_RES_ACCEPTED = 0X05;
uint8_t const DATA_RES_ACCEPTED = 0x05;
//------------------------------------------------------------------------------
/** Card IDentification (CID) register */
typedef struct CID {
@ -203,7 +203,7 @@ typedef struct CSDV2 {
unsigned char reserved1 : 6;
unsigned char csd_ver : 2;
// byte 1
/** fixed to 0X0E */
/** fixed to 0x0E */
unsigned char taac;
// byte 2
/** fixed to 0 */

96
Marlin/SdVolume.cpp
View File

@ -73,14 +73,14 @@ bool SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
// search the FAT for free clusters
for (uint32_t n = 0;; n++, endCluster++) {
// can't find space checked all clusters
if (n >= clusterCount_) goto fail;
if (n >= clusterCount_) goto FAIL;
// past end - start from beginning of FAT
if (endCluster > fatEnd) {
bgnCluster = endCluster = 2;
}
uint32_t f;
if (!fatGet(endCluster, &f)) goto fail;
if (!fatGet(endCluster, &f)) goto FAIL;
if (f != 0) {
// cluster in use try next cluster as bgnCluster
@ -92,16 +92,16 @@ bool SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
}
}
// mark end of chain
if (!fatPutEOC(endCluster)) goto fail;
if (!fatPutEOC(endCluster)) goto FAIL;
// link clusters
while (endCluster > bgnCluster) {
if (!fatPut(endCluster - 1, endCluster)) goto fail;
if (!fatPut(endCluster - 1, endCluster)) goto FAIL;
endCluster--;
}
if (*curCluster != 0) {
// connect chains
if (!fatPut(*curCluster, bgnCluster)) goto fail;
if (!fatPut(*curCluster, bgnCluster)) goto FAIL;
}
// return first cluster number to caller
*curCluster = bgnCluster;
@ -110,38 +110,38 @@ bool SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
if (setStart) allocSearchStart_ = bgnCluster + 1;
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
bool SdVolume::cacheFlush() {
if (cacheDirty_) {
if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data)) {
goto fail;
goto FAIL;
}
// mirror FAT tables
if (cacheMirrorBlock_) {
if (!sdCard_->writeBlock(cacheMirrorBlock_, cacheBuffer_.data)) {
goto fail;
goto FAIL;
}
cacheMirrorBlock_ = 0;
}
cacheDirty_ = 0;
}
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
bool SdVolume::cacheRawBlock(uint32_t blockNumber, bool dirty) {
if (cacheBlockNumber_ != blockNumber) {
if (!cacheFlush()) goto fail;
if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) goto fail;
if (!cacheFlush()) goto FAIL;
if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) goto FAIL;
cacheBlockNumber_ = blockNumber;
}
if (dirty) cacheDirty_ = true;
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -149,33 +149,33 @@ fail:
bool SdVolume::chainSize(uint32_t cluster, uint32_t* size) {
uint32_t s = 0;
do {
if (!fatGet(cluster, &cluster)) goto fail;
if (!fatGet(cluster, &cluster)) goto FAIL;
s += 512UL << clusterSizeShift_;
} while (!isEOC(cluster));
*size = s;
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
// Fetch a FAT entry
bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) {
uint32_t lba;
if (cluster > (clusterCount_ + 1)) goto fail;
if (cluster > (clusterCount_ + 1)) goto FAIL;
if (FAT12_SUPPORT && fatType_ == 12) {
uint16_t index = cluster;
index += index >> 1;
lba = fatStartBlock_ + (index >> 9);
if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto fail;
index &= 0X1FF;
if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto FAIL;
index &= 0x1FF;
uint16_t tmp = cacheBuffer_.data[index];
index++;
if (index == 512) {
if (!cacheRawBlock(lba + 1, CACHE_FOR_READ)) goto fail;
if (!cacheRawBlock(lba + 1, CACHE_FOR_READ)) goto FAIL;
index = 0;
}
tmp |= cacheBuffer_.data[index] << 8;
*value = cluster & 1 ? tmp >> 4 : tmp & 0XFFF;
*value = cluster & 1 ? tmp >> 4 : tmp & 0xFFF;
return true;
}
if (fatType_ == 16) {
@ -185,19 +185,19 @@ bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) {
lba = fatStartBlock_ + (cluster >> 7);
}
else {
goto fail;
goto FAIL;
}
if (lba != cacheBlockNumber_) {
if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto fail;
if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto FAIL;
}
if (fatType_ == 16) {
*value = cacheBuffer_.fat16[cluster & 0XFF];
*value = cacheBuffer_.fat16[cluster & 0xFF];
}
else {
*value = cacheBuffer_.fat32[cluster & 0X7F] & FAT32MASK;
*value = cacheBuffer_.fat32[cluster & 0x7F] & FAT32MASK;
}
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -205,19 +205,19 @@ fail:
bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
uint32_t lba;
// error if reserved cluster
if (cluster < 2) goto fail;
if (cluster < 2) goto FAIL;
// error if not in FAT
if (cluster > (clusterCount_ + 1)) goto fail;
if (cluster > (clusterCount_ + 1)) goto FAIL;
if (FAT12_SUPPORT && fatType_ == 12) {
uint16_t index = cluster;
index += index >> 1;
lba = fatStartBlock_ + (index >> 9);
if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
// mirror second FAT
if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
index &= 0X1FF;
index &= 0x1FF;
uint8_t tmp = value;
if (cluster & 1) {
tmp = (cacheBuffer_.data[index] & 0XF) | tmp << 4;
@ -227,13 +227,13 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
if (index == 512) {
lba++;
index = 0;
if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
// mirror second FAT
if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
}
tmp = value >> 4;
if (!(cluster & 1)) {
tmp = ((cacheBuffer_.data[index] & 0XF0)) | tmp >> 4;
tmp = ((cacheBuffer_.data[index] & 0xF0)) | tmp >> 4;
}
cacheBuffer_.data[index] = tmp;
return true;
@ -245,20 +245,20 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
lba = fatStartBlock_ + (cluster >> 7);
}
else {
goto fail;
goto FAIL;
}
if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
// store entry
if (fatType_ == 16) {
cacheBuffer_.fat16[cluster & 0XFF] = value;
cacheBuffer_.fat16[cluster & 0xFF] = value;
}
else {
cacheBuffer_.fat32[cluster & 0X7F] = value;
cacheBuffer_.fat32[cluster & 0x7F] = value;
}
// mirror second FAT
if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -270,16 +270,16 @@ bool SdVolume::freeChain(uint32_t cluster) {
allocSearchStart_ = 2;
do {
if (!fatGet(cluster, &next)) goto fail;
if (!fatGet(cluster, &next)) goto FAIL;
// free cluster
if (!fatPut(cluster, 0)) goto fail;
if (!fatPut(cluster, 0)) goto FAIL;
cluster = next;
} while (!isEOC(cluster));
return true;
fail:
FAIL:
return false;
}
//------------------------------------------------------------------------------
@ -344,30 +344,30 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
allocSearchStart_ = 2;
cacheDirty_ = 0; // cacheFlush() will write block if true
cacheMirrorBlock_ = 0;
cacheBlockNumber_ = 0XFFFFFFFF;
cacheBlockNumber_ = 0xFFFFFFFF;
// if part == 0 assume super floppy with FAT boot sector in block zero
// if part > 0 assume mbr volume with partition table
if (part) {
if (part > 4)goto fail;
if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto fail;
if (part > 4)goto FAIL;
if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto FAIL;
part_t* p = &cacheBuffer_.mbr.part[part - 1];
if ((p->boot & 0X7F) != 0 ||
if ((p->boot & 0x7F) != 0 ||
p->totalSectors < 100 ||
p->firstSector == 0) {
// not a valid partition
goto fail;
goto FAIL;
}
volumeStartBlock = p->firstSector;
}
if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto fail;
if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto FAIL;
fbs = &cacheBuffer_.fbs32;
if (fbs->bytesPerSector != 512 ||
fbs->fatCount == 0 ||
fbs->reservedSectorCount == 0 ||
fbs->sectorsPerCluster == 0) {
// not valid FAT volume
goto fail;
goto FAIL;
}
fatCount_ = fbs->fatCount;
blocksPerCluster_ = fbs->sectorsPerCluster;
@ -375,7 +375,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
clusterSizeShift_ = 0;
while (blocksPerCluster_ != _BV(clusterSizeShift_)) {
// error if not power of 2
if (clusterSizeShift_++ > 7) goto fail;
if (clusterSizeShift_++ > 7) goto FAIL;
}
blocksPerFat_ = fbs->sectorsPerFat16 ?
fbs->sectorsPerFat16 : fbs->sectorsPerFat32;
@ -404,7 +404,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
// FAT type is determined by cluster count
if (clusterCount_ < 4085) {
fatType_ = 12;
if (!FAT12_SUPPORT) goto fail;
if (!FAT12_SUPPORT) goto FAIL;
}
else if (clusterCount_ < 65525) {
fatType_ = 16;
@ -414,7 +414,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
fatType_ = 32;
}
return true;
fail:
FAIL:
return false;
}
#endif

2
Marlin/SdVolume.h
View File

@ -76,7 +76,7 @@ class SdVolume {
*/
cache_t* cacheClear() {
if (!cacheFlush()) return 0;
cacheBlockNumber_ = 0XFFFFFFFF;
cacheBlockNumber_ = 0xFFFFFFFF;
return &cacheBuffer_;
}
/** Initialize a FAT volume. Try partition one first then try super

2
Marlin/example_configurations/Creality/CR-10/Configuration.h
View File

@ -74,7 +74,7 @@
// User-specified version info of this build to display in [Pronterface, etc] terminal window during
// startup. Implementation of an idea by Prof Braino to inform user that any changes made to this
// build by the user have been successfully uploaded into firmware.
#define STRING_CONFIG_H_AUTHOR "(none, default config)" // Who made the changes.
#define STRING_CONFIG_H_AUTHOR "(Creality CR-10)" // Who made the changes.
#define SHOW_BOOTSCREEN
#define STRING_SPLASH_LINE1 SHORT_BUILD_VERSION // will be shown during bootup in line 1
//#define STRING_SPLASH_LINE2 WEBSITE_URL // will be shown during bootup in line 2

2
Marlin/pca9632.cpp
View File

@ -45,7 +45,7 @@
#define PCA9632_PWM3 0x05
#define PCA9632_GRPPWM 0x06
#define PCA9632_GRPFREQ 0x07
#define PCA9632_LEDOUT 0X08
#define PCA9632_LEDOUT 0x08
#define PCA9632_SUBADR1 0x09
#define PCA9632_SUBADR2 0x0A
#define PCA9632_SUBADR3 0x0B

2
Marlin/pins_MELZI_CREALITY.h
View File

@ -24,7 +24,7 @@
* Melzi (Creality) pin assignments
*/
#define BOARD_NAME "Melzi Creality"
#define BOARD_NAME "Melzi (Creality)"
#ifdef __AVR_ATmega1284P__
#define LARGE_FLASH true

2
Marlin/pins_MELZI_MAKR3D.h
View File

@ -24,7 +24,7 @@
* Melzi with ATmega1284 (MaKr3d version) pin assignments
*/
#define BOARD_NAME "Melzi ATmega1284"
#define BOARD_NAME "Melzi (ATmega1284)"
#ifdef __AVR_ATmega1284P__
#define LARGE_FLASH true

6
Marlin/softspi.h
View File

@ -455,7 +455,7 @@ void badPinCheck(uint8_t pin) {
static inline __attribute__((always_inline))
void fastBitWriteSafe(volatile uint8_t* address, uint8_t bit, bool level) {
uint8_t oldSREG;
if (address > (uint8_t*)0X5F) {
if (address > (uint8_t*)0x5F) {
oldSREG = SREG;
cli();
}
@ -464,7 +464,7 @@ void fastBitWriteSafe(volatile uint8_t* address, uint8_t bit, bool level) {
} else {
*address &= ~(1 << bit);
}
if (address > (uint8_t*)0X5F) {
if (address > (uint8_t*)0x5F) {
SREG = oldSREG;
}
}
@ -488,7 +488,7 @@ bool fastDigitalRead(uint8_t pin) {
static inline __attribute__((always_inline))
void fastDigitalToggle(uint8_t pin) {
badPinCheck(pin);
if (pinMap[pin].pin > (uint8_t*)0X5F) {
if (pinMap[pin].pin > (uint8_t*)0x5F) {
// must write bit to high address port
*pinMap[pin].pin = 1 << pinMap[pin].bit;
} else {

13
Marlin/ultralcd.cpp
View File

@ -2720,11 +2720,16 @@ void kill_screen(const char* lcd_msg) {
screenFunc_t _manual_move_func_ptr;
void lcd_move_menu_10mm() { move_menu_scale = 10.0; lcd_goto_screen(_manual_move_func_ptr); }
void lcd_move_menu_1mm() { move_menu_scale = 1.0; lcd_goto_screen(_manual_move_func_ptr); }
void lcd_move_menu_01mm() { move_menu_scale = 0.1; lcd_goto_screen(_manual_move_func_ptr); }
void _goto_manual_move(const float scale) {
defer_return_to_status = true;
move_menu_scale = scale;
lcd_goto_screen(_manual_move_func_ptr);
}
void lcd_move_menu_10mm() { _goto_manual_move(10.0); }
void lcd_move_menu_1mm() { _goto_manual_move( 1.0); }
void lcd_move_menu_01mm() { _goto_manual_move( 0.1); }
void _lcd_move_distance_menu(AxisEnum axis, screenFunc_t func) {
void _lcd_move_distance_menu(const AxisEnum axis, const screenFunc_t func) {
_manual_move_func_ptr = func;
START_MENU();
if (LCD_HEIGHT >= 4) {

Write Preview
Loading…
Cancel
Save