From 35d5a7bdff674b17c8094373ea4a80fc24850a64 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Wed, 9 Aug 2017 12:31:18 -0500 Subject: [PATCH 1/6] Tweak CR-10 config/pins --- Marlin/example_configurations/Creality/CR-10/Configuration.h | 2 +- Marlin/pins_MELZI_CREALITY.h | 2 +- Marlin/pins_MELZI_MAKR3D.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Marlin/example_configurations/Creality/CR-10/Configuration.h b/Marlin/example_configurations/Creality/CR-10/Configuration.h index b4817e4ae..53e703b81 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/pins_MELZI_CREALITY.h b/Marlin/pins_MELZI_CREALITY.h index d08bba1c3..d66f589fe 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 83deb884c..bd86f59c0 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 From 9d95b1b4df0fcdd853b83ca2e065c0d626e6887a Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Sun, 6 Aug 2017 23:29:35 -0500 Subject: [PATCH 2/6] Tweak Conditionals_post.h --- Marlin/Conditionals_post.h | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/Marlin/Conditionals_post.h b/Marlin/Conditionals_post.h index 7d4a4a457..e3878ecb9 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 */ From 0938c62b4826e62549f0f86818fd8d4c8e94d228 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Wed, 9 Aug 2017 12:31:00 -0500 Subject: [PATCH 3/6] Neater position_is_reachable call --- Marlin/Marlin_main.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 185dfb413..f9db4f49b 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; From 75e6f72c89d9a2afc232b5097ced3f5d8b9a3df1 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Wed, 9 Aug 2017 13:23:14 -0500 Subject: [PATCH 4/6] Fix hexadecimal number formatting --- Marlin/Sd2Card.cpp | 28 ++++++++--------- Marlin/Sd2Card.h | 22 ++++++------- Marlin/SdBaseFile.cpp | 14 ++++----- Marlin/SdBaseFile.h | 26 ++++++++-------- Marlin/SdFatStructs.h | 72 +++++++++++++++++++++---------------------- Marlin/SdInfo.h | 52 +++++++++++++++---------------- Marlin/SdVolume.cpp | 20 ++++++------ Marlin/SdVolume.h | 2 +- Marlin/pca9632.cpp | 2 +- Marlin/softspi.h | 6 ++-- 10 files changed, 122 insertions(+), 122 deletions(-) diff --git a/Marlin/Sd2Card.cpp b/Marlin/Sd2Card.cpp index 74de29b9d..ce07846f1 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_; } //------------------------------------------------------------------------------ @@ -329,7 +329,7 @@ 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) { @@ -345,14 +345,14 @@ 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; } 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 @@ -367,7 +367,7 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { error(SD_CARD_ERROR_CMD58); 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(); } @@ -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; } diff --git a/Marlin/Sd2Card.h b/Marlin/Sd2Card.h index f91958ac0..1fbd52747 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 97b4fa00f..0dc165cd6 100644 --- a/Marlin/SdBaseFile.cpp +++ b/Marlin/SdBaseFile.cpp @@ -57,7 +57,7 @@ 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; @@ -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 @@ -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); } @@ -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'; @@ -1513,7 +1513,7 @@ bool SdBaseFile::sync() { 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 @@ -1738,7 +1738,7 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) { 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) { @@ -1774,7 +1774,7 @@ 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; } diff --git a/Marlin/SdBaseFile.h b/Marlin/SdBaseFile.h index 02ab70543..02daa7b7f 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 3e78aa292..52c815d76 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 f4b36b7ae..88b465690 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 4166c0661..701b116c2 100644 --- a/Marlin/SdVolume.cpp +++ b/Marlin/SdVolume.cpp @@ -167,7 +167,7 @@ bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) { index += index >> 1; lba = fatStartBlock_ + (index >> 9); if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto fail; - index &= 0X1FF; + index &= 0x1FF; uint16_t tmp = cacheBuffer_.data[index]; index++; if (index == 512) { @@ -175,7 +175,7 @@ bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) { 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) { @@ -191,10 +191,10 @@ bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) { 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: @@ -217,7 +217,7 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t value) { 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; @@ -233,7 +233,7 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t value) { } 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; @@ -250,10 +250,10 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t value) { 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_; @@ -344,7 +344,7 @@ 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 @@ -352,7 +352,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) { 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 diff --git a/Marlin/SdVolume.h b/Marlin/SdVolume.h index 990248d6a..3041a6dfb 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/pca9632.cpp b/Marlin/pca9632.cpp index fe0647639..37f7bd7df 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/softspi.h b/Marlin/softspi.h index 24ee33fed..3b77e443b 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 { From 8fd58cd6dca91412dec589dcfb85fa6f29d5429f Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Fri, 11 Aug 2017 15:55:07 -0500 Subject: [PATCH 5/6] Patch goto labels for consistency --- Marlin/Sd2Card.cpp | 76 +++++------ Marlin/SdBaseFile.cpp | 288 +++++++++++++++++++++--------------------- Marlin/SdVolume.cpp | 76 +++++------ 3 files changed, 220 insertions(+), 220 deletions(-) diff --git a/Marlin/Sd2Card.cpp b/Marlin/Sd2Card.cpp index ce07846f1..2afe9a8b4 100644 --- a/Marlin/Sd2Card.cpp +++ b/Marlin/Sd2Card.cpp @@ -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; } @@ -335,7 +335,7 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { 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 @@ -347,7 +347,7 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { for (uint8_t i = 0; i < 4; i++) status_ = spiRec(); if (status_ != 0xAA) { error(SD_CARD_ERROR_CMD8); - goto fail; + goto FAIL; } type(SD_CARD_TYPE_SD2); } @@ -358,14 +358,14 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { // 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); // discard rest of ocr - contains allowed voltage range @@ -380,7 +380,7 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { return true; #endif // SOFTWARE_SPI -fail: + FAIL: chipSelectHigh(); return false; } @@ -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(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/SdBaseFile.cpp b/Marlin/SdBaseFile.cpp index 0dc165cd6..95fc2b62b 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)); @@ -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_); @@ -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; } @@ -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,12 +1502,12 @@ 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_; @@ -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,11 +1729,11 @@ 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) { @@ -1744,7 +1744,7 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) { 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; @@ -1776,18 +1776,18 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) { // invalidate cache if block is in cache 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/SdVolume.cpp b/Marlin/SdVolume.cpp index 701b116c2..4093cb5e0 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,29 +149,29 @@ 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; + 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; @@ -185,10 +185,10 @@ 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]; @@ -197,7 +197,7 @@ bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) { *value = cacheBuffer_.fat32[cluster & 0x7F] & FAT32MASK; } return true; -fail: + FAIL: return false; } //------------------------------------------------------------------------------ @@ -205,16 +205,16 @@ 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; @@ -227,7 +227,7 @@ 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_; } @@ -245,9 +245,9 @@ 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; @@ -258,7 +258,7 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t 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; } //------------------------------------------------------------------------------ @@ -349,25 +349,25 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) { // 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 || 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 From 3be9c19f12fbc7eeb8d9b49bbf034c114c406434 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Mon, 14 Aug 2017 19:49:14 -0500 Subject: [PATCH 6/6] Hold on move axis screens --- Marlin/ultralcd.cpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp index 8de1e0129..baefcf97f 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) {