diff --git a/Marlin/Conditionals_post.h b/Marlin/Conditionals_post.h
index 7d4a4a457a..e3878ecb9b 100644
--- a/Marlin/Conditionals_post.h
+++ b/Marlin/Conditionals_post.h
@@ -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
*/
diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp
index 185dfb4137..f9db4f49ba 100644
--- a/Marlin/Marlin_main.cpp
+++ b/Marlin/Marlin_main.cpp
@@ -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;
diff --git a/Marlin/Sd2Card.cpp b/Marlin/Sd2Card.cpp
index 74de29b9dd..2afe9a8b48 100644
--- a/Marlin/Sd2Card.cpp
+++ b/Marlin/Sd2Card.cpp
@@ -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;
diff --git a/Marlin/Sd2Card.h b/Marlin/Sd2Card.h
index f91958ac03..1fbd527473 100644
--- a/Marlin/Sd2Card.h
+++ b/Marlin/Sd2Card.h
@@ -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 */
diff --git a/Marlin/SdBaseFile.cpp b/Marlin/SdBaseFile.cpp
index 97b4fa00f8..95fc2b62b6 100644
--- a/Marlin/SdBaseFile.cpp
+++ b/Marlin/SdBaseFile.cpp
@@ -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;
diff --git a/Marlin/SdBaseFile.h b/Marlin/SdBaseFile.h
index 02ab705430..02daa7b7f2 100644
--- a/Marlin/SdBaseFile.h
+++ b/Marlin/SdBaseFile.h
@@ -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
diff --git a/Marlin/SdFatStructs.h b/Marlin/SdFatStructs.h
index 3e78aa2927..52c815d763 100644
--- a/Marlin/SdFatStructs.h
+++ b/Marlin/SdFatStructs.h
@@ -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.
*
diff --git a/Marlin/SdInfo.h b/Marlin/SdInfo.h
index f4b36b7aed..88b4656908 100644
--- a/Marlin/SdInfo.h
+++ b/Marlin/SdInfo.h
@@ -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 */
diff --git a/Marlin/SdVolume.cpp b/Marlin/SdVolume.cpp
index 4166c0661a..4093cb5e04 100644
--- a/Marlin/SdVolume.cpp
+++ b/Marlin/SdVolume.cpp
@@ -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
diff --git a/Marlin/SdVolume.h b/Marlin/SdVolume.h
index 990248d6a6..3041a6dfb4 100644
--- a/Marlin/SdVolume.h
+++ b/Marlin/SdVolume.h
@@ -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
diff --git a/Marlin/example_configurations/Creality/CR-10/Configuration.h b/Marlin/example_configurations/Creality/CR-10/Configuration.h
index b4817e4aef..53e703b811 100644
--- a/Marlin/example_configurations/Creality/CR-10/Configuration.h
+++ b/Marlin/example_configurations/Creality/CR-10/Configuration.h
@@ -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
diff --git a/Marlin/pca9632.cpp b/Marlin/pca9632.cpp
index fe0647639d..37f7bd7df7 100644
--- a/Marlin/pca9632.cpp
+++ b/Marlin/pca9632.cpp
@@ -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
diff --git a/Marlin/pins_MELZI_CREALITY.h b/Marlin/pins_MELZI_CREALITY.h
index d08bba1c3b..d66f589fea 100644
--- a/Marlin/pins_MELZI_CREALITY.h
+++ b/Marlin/pins_MELZI_CREALITY.h
@@ -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
diff --git a/Marlin/pins_MELZI_MAKR3D.h b/Marlin/pins_MELZI_MAKR3D.h
index 83deb884c5..bd86f59c01 100644
--- a/Marlin/pins_MELZI_MAKR3D.h
+++ b/Marlin/pins_MELZI_MAKR3D.h
@@ -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
diff --git a/Marlin/softspi.h b/Marlin/softspi.h
index 24ee33fed1..3b77e443b3 100644
--- a/Marlin/softspi.h
+++ b/Marlin/softspi.h
@@ -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 {
diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp
index 8de1e0129f..baefcf97fe 100644
--- a/Marlin/ultralcd.cpp
+++ b/Marlin/ultralcd.cpp
@@ -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) {