Remove this, using a different SDFat anyway

lib/SdFat_NoArduino/doc/SdErrorCodes.txt

@@ -1,51 +0,0 @@
-2022-07-01
-
-Run the SdErrorCode example to produce an updated list.
-
-Code,Symbol - failed operation
-0X00,SD_CARD_ERROR_NONE - No error
-0X01,SD_CARD_ERROR_CMD0 - Card reset failed
-0X02,SD_CARD_ERROR_CMD2 - SDIO read CID
-0X03,SD_CARD_ERROR_CMD3 - SDIO publish RCA
-0X04,SD_CARD_ERROR_CMD6 - Switch card function
-0X05,SD_CARD_ERROR_CMD7 - SDIO card select
-0X06,SD_CARD_ERROR_CMD8 - Send and check interface settings
-0X07,SD_CARD_ERROR_CMD9 - Read CSD data
-0X08,SD_CARD_ERROR_CMD10 - Read CID data
-0X09,SD_CARD_ERROR_CMD12 - Stop multiple block read
-0X0A,SD_CARD_ERROR_CMD13 - Read card status
-0X0B,SD_CARD_ERROR_CMD17 - Read single block
-0X0C,SD_CARD_ERROR_CMD18 - Read multiple blocks
-0X0D,SD_CARD_ERROR_CMD24 - Write single block
-0X0E,SD_CARD_ERROR_CMD25 - Write multiple blocks
-0X0F,SD_CARD_ERROR_CMD32 - Set first erase block
-0X10,SD_CARD_ERROR_CMD33 - Set last erase block
-0X11,SD_CARD_ERROR_CMD38 - Erase selected blocks
-0X12,SD_CARD_ERROR_CMD58 - Read OCR register
-0X13,SD_CARD_ERROR_CMD59 - Set CRC mode
-0X14,SD_CARD_ERROR_ACMD6 - Set SDIO bus width
-0X15,SD_CARD_ERROR_ACMD13 - Read extended status
-0X16,SD_CARD_ERROR_ACMD23 - Set pre-erased count
-0X17,SD_CARD_ERROR_ACMD41 - Activate card initialization
-0X18,SD_CARD_ERROR_ACMD51 - Read SCR data
-0X19,SD_CARD_ERROR_READ_TOKEN - Bad read data token
-0X1A,SD_CARD_ERROR_READ_CRC - Read CRC error
-0X1B,SD_CARD_ERROR_READ_FIFO - SDIO fifo read timeout
-0X1C,SD_CARD_ERROR_READ_REG - Read CID or CSD failed.
-0X1D,SD_CARD_ERROR_READ_START - Bad readStart argument
-0X1E,SD_CARD_ERROR_READ_TIMEOUT - Read data timeout
-0X1F,SD_CARD_ERROR_STOP_TRAN - Multiple block stop failed
-0X20,SD_CARD_ERROR_TRANSFER_COMPLETE - SDIO transfer complete
-0X21,SD_CARD_ERROR_WRITE_DATA - Write data not accepted
-0X22,SD_CARD_ERROR_WRITE_FIFO - SDIO fifo write timeout
-0X23,SD_CARD_ERROR_WRITE_START - Bad writeStart argument
-0X24,SD_CARD_ERROR_WRITE_PROGRAMMING - Flash programming
-0X25,SD_CARD_ERROR_WRITE_TIMEOUT - Write timeout
-0X26,SD_CARD_ERROR_DMA - DMA transfer failed
-0X27,SD_CARD_ERROR_ERASE - Card did not accept erase commands
-0X28,SD_CARD_ERROR_ERASE_SINGLE_SECTOR - Card does not support erase
-0X29,SD_CARD_ERROR_ERASE_TIMEOUT - Erase command timeout
-0X2A,SD_CARD_ERROR_INIT_NOT_CALLED - Card has not been initialized
-0X2B,SD_CARD_ERROR_INVALID_CARD_CONFIG - Invalid card config
-0X2C,SD_CARD_ERROR_FUNCTION_NOT_SUPPORTED - Unsupported SDIO command
-0X2D,SD_CARD_ERROR_UNKNOWN - Unknown error

lib/SdFat_NoArduino/doc/mainpage.h

@@ -1,289 +0,0 @@
-/**
- * Copyright (c) 2011-2021 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
-\mainpage Arduino %SdFat Library
-
-\section Warn Warnings for SdFat V2
-
-This is a major new version of SdFat. It is mostly
-backward compatible with SdFat Version 1 for FAT16/FAT32 cards.
-
-You should edit SdFatConfig.h to select features. The default version of
-SdFatConfig.h is suitable for UNO and other small AVR boards.
-
-\section Intro Introduction
-
-The Arduino %SdFat library supports FAT16, FAT32, and exFAT file systems
-on Standard SD, SDHC, and SDXC cards.
-
-In %SdFat version 1, SdFat and File are the main classes.
-
-In %SdFat version 2, SdFat and File are defined by typedefs in terms of the
-following classes.
-
-The file system classes in the %SdFat library are SdFat32, SdExFat, and SdFs.
-SdFat32 supports FAT16 and FAT32. SdExFat supports exFAT, SdFs supports
-FAT16, FAT32, and exFAT.
-
-The corresponding file classes are File32, ExFile, and FsFile.
-
-The types for SdFat and File are defined in SdFatConfig.h. This version
-uses FAT16/FAT32 for small AVR boards and FAT16/FAT32/exFAT for all other
-boards.
-
-\code{.cpp}
-// File types for SdFat, File, SdFile, SdBaseFile, fstream,
-// ifstream, and ofstream.
-//
-// Set SDFAT_FILE_TYPE to:
-// 1 for FAT16/FAT32, 2 for exFAT, 3 for FAT16/FAT32 and exFAT.
-//
-#if defined(__AVR__) && FLASHEND < 0X8000
-// FAT16/FAT32 for 32K AVR boards.
-#define SDFAT_FILE_TYPE 1
-#else  // defined(__AVR__) && FLASHEND < 0X8000
-// FAT16/FAT32 and exFAT for all other boards.
-#define SDFAT_FILE_TYPE 3
-#endif  // defined(__AVR__) && FLASHEND < 0X8000
-\endcode
-
-It is possible to use option three, support or FAT16/FAT32 and exFat
-on an Uno or other AVR board with 32KB flash and 2KB SRAM but memory
-will be very limited.
-
-Uno memory use for a simple data logger is:
-
-> option 1, FAT16/FAT32, 11902 bytes of flash and 855 bytes of SRAM.
->
-> option 2, exFAT, 14942 bytes of flash and 895 bytes of SRAM.
->
-> option 3, FAT16/FAT32 and exFAT, 21834 bytes of flash and 908 bytes of SRAM.
-
-Please read documentation under the above classes tab for more information.
-
-A number of example are provided in the %SdFat/examples folder.  These were
-developed to test %SdFat and illustrate its use.
-
-\section exFAT exFAT Features
-
-exFAT has many features not available in FAT16/FAT32.
-
-Files larger than 4GiB, 64-bit file size and file position.
-
-Free space allocation performance improved by using a free space bitmap.
-
-Removal of the physical "." and ".." directory entries that appear in
-FAT16/FAT32 subdirectories.
-
-Better support for large flash pages with boundary alignment offsets
-for the FAT table and data region.
-
-exFAT files have two separate 64-bit length fields.  The DataLength
-field indicate how much space is allocate to the file. The ValidDataLength
-field indicates how much actual data has been written to the file.
-
-An exFAT file can be contiguous with pre-allocate clusters and bypass the
-use of the FAT table.  In this case the contiguous flag is set in the
-directory entry.  This allows an entire file to be written as one large
-multi-block write.
-
-\section SDPath Paths and Working Directories
-
-Relative paths in %SdFat are resolved in a manner similar to Windows.
-
-Each instance of SdFat32, SdExFat, and SdFs has a current directory.
-This directory is called the volume working directory, vwd.
-Initially this directory is the root directory for the volume.
-
-The volume working directory is changed by calling the chdir(path).
-
-The call sd.chdir("/2014") will change the volume working directory
-for sd to "/2014", assuming "/2014" exists.
-
-Relative paths for member functions are resolved by starting at
-the volume working directory.
-
-For example, the call sd.mkdir("April") will create the directory
-"/2014/April" assuming the volume working directory is "/2014".
-
-There is current working directory, cwd, that is used to resolve paths
-for file.open() calls.
-
-For a single SD card, the current working directory is always the volume
-working directory for that card.
-
-For multiple SD cards the current working directory is set to the volume
-working directory of a card by calling the chvol() member function.
-The chvol() call is like the Windows \<drive letter>: command.
-
-The call sd2.chvol() will set the current working directory to the volume
-working directory for sd2.
-
-If the volume working directory for sd2 is "/music" the call
-
-file.open("BigBand.wav", O_READ);
-
-will open "/music/BigBand.wav" on sd2.
-
-\section Install Installation
-
-You must manually install %SdFat by renaming the download folder %SdFat
-and copy the %SdFat folder to the Arduino libraries folder in your
-sketchbook folder.
-
-It will be necessary to unzip and rename the folder if you download a zip
-file from GitHub.
-
-See the Manual installation section of this guide.
-
-http://arduino.cc/en/Guide/Libraries
-
-\section SDconfig SdFat Configuration
-
-Several configuration options may be changed by editing the SdFatConfig.h
-file in the %SdFat/src folder.
-
-Here are a few of the key options.
-
-If the symbol ENABLE_DEDICATED_SPI is nonzero, multi-block SD I/O may
-be used for better performance.  The SPI bus may not be shared with
-other devices in this mode.
-
-The symbol SPI_DRIVER_SELECT is used to select the SPI driver.
-
-> If the symbol SPI_DRIVER_SELECT is:
->
-> 0 - An optimized custom SPI driver is used if it exists
->     else the standard library driver is used.
->
-> 1 - The standard library driver is always used.
->
-> 2 - The software SPI driver is always used.
->
-> 3 - An external SPI driver derived from SdSpiBaseClass is always used.
-
-To enable SD card CRC checking in SPI mode set USE_SD_CRC nonzero.
-
-See SdFatConfig.h for other options.
-
-\section Hardware Hardware Configuration
-
-The hardware interface to the SD card should not use a resistor based level
-shifter. Resistor based level shifters results in signal rise times that are
- too slow for many newer SD cards.
-
-
-\section HowTo How to format SD Cards
-
-The best way to restore an SD card's format on a PC or Mac is to use
-SDFormatter which can be downloaded from:
-
-http://www.sdcard.org/downloads
-
-A formatter program, SdFormatter.ino, is included in the
-%SdFat/examples/SdFormatter directory.  This program attempts to
-emulate SD Association's SDFormatter.
-
-SDFormatter aligns flash erase boundaries with file
-system structures which reduces write latency and file system overhead.
-
-The PC/Mac SDFormatter does not have an option for FAT type so it may format
-very small cards as FAT12.  Use the %SdFormatter example to force FAT16
-formatting of small cards.
-
-Do not format the SD card with an OS utility, OS utilities do not format SD
-cards in conformance with the SD standard.
-
-You should use a freshly formatted SD card for best performance.  FAT
-file systems become slower if many files have been created and deleted.
-This is because the directory entry for a deleted file is marked as deleted,
-but is not deleted.  When a new file is created, these entries must be scanned
-before creating the file.  Also files can become
-fragmented which causes reads and writes to be slower.
-
-\section ExampleFiles Examples
-
-A number of examples are provided in the SdFat/examples folder.
-
-To access these examples from the Arduino development environment
-go to:  %File -> Examples -> %SdFat -> \<program Name\>
-
-Compile, upload to your Arduino and click on Serial Monitor to run
-the example.
-
-Here is a list:
-
-AvrAdcLogger - Fast AVR ADC logger using Timer/ADC interrupts.
-
-BackwardCompatibility - Demonstrate SD.h compatibility with %SdFat.h.
-
-bench - A read/write benchmark.
-
-%BufferedPrint - Demo a buffered print class for AVR loggers.
-
-debug folder - Some of my debug programs - will be remove in the future.
-
-DirectoryFunctions - Use of chdir(), ls(), mkdir(), and rmdir().
-
-examplesV1 folder - Examples from SdFat V1 for compatibility tests.
-
-ExFatLogger - A data-logger optimized for exFAT features.
-
-MinimumSizeSdReader - Example of small file reader for FAT16/FAT32.
-
-OpenNext - Open all files in the root dir and print their filename.
-
-QuickStart - Quick hardware test for SPI card access.
-
-ReadCsvFile - Function to read a CSV text file one field at a time.
-
-rename - demonstrates use of rename().
-
-RtcTimestampTest - Demonstration of timestamps with RTClib.
-
-SdErrorCodes - Produce a list of error codes.
-
-SdFormatter - This program will format an SD, SDHC, or SDXC card.
-
-SdInfo - Initialize an SD card and analyze its structure for trouble shooting.
-
-SoftwareSpi - Demo of limited Software SPI support in SdFat V2.
-
-STM32Test - Example use of two SPI ports on an STM32 board.
-
-TeensyDmaAdcLogger - Fast logger using DMA ADC.
-
-TeensyRtcTimestamp - %File timestamps for Teensy3.
-
-TeensySdioDemo - Demo of SDIO and SPI modes for the Teensy 3.5/3.6 built-in SD.
-
-TeensySdioLogger -  Fast logger using a ring buffer.
-
-UnicodeFilenames - Test program for Unicode file names.
-
-UserChipSelectFunction - Useful for port expanders or replacement of the standard GPIO functions.
-
-UserSPIDriver - An example of an external SPI driver.
- */

lib/SdFat_NoArduino/examples/AvrAdcLogger/AvrAdcLogger.ino

@@ -1,899 +0,0 @@
-/**
- * This program logs data from the Arduino ADC to a binary file.
- *
- * Samples are logged at regular intervals. Each Sample consists of the ADC
- * values for the analog pins defined in the PIN_LIST array.  The pins numbers
- * may be in any order.
- *
- * Edit the configuration constants below to set the sample pins, sample rate,
- * and other configuration values.
- *
- * If your SD card has a long write latency, it may be necessary to use
- * slower sample rates.  Using a Mega Arduino helps overcome latency
- * problems since more 64 byte buffer blocks will be used.
- *
- * Each 64 byte data block in the file has a four byte header followed by up
- * to 60 bytes of data. (60 values in 8-bit mode or 30 values in 10-bit mode)
- * Each block contains an integral number of samples with unused space at the
- * end of the block.
- *
- */
-#ifdef __AVR__
-#include <SPI.h>
-#include "SdFat.h"
-#include "BufferedPrint.h"
-#include "FreeStack.h"
-#include "AvrAdcLogger.h"
-
-// Save SRAM if 328.
-#ifdef __AVR_ATmega328P__
-#include "MinimumSerial.h"
-MinimumSerial MinSerial;
-#define Serial MinSerial
-#endif  // __AVR_ATmega328P__
-//------------------------------------------------------------------------------
-// This example was designed for exFAT but will support FAT16/FAT32.
-//
-// Note: Uno will not support SD_FAT_TYPE = 3.
-// SD_FAT_TYPE = 0 for SdFat/File as defined in SdFatConfig.h,
-// 1 for FAT16/FAT32, 2 for exFAT, 3 for FAT16/FAT32 and exFAT.
-#define SD_FAT_TYPE 2
-//------------------------------------------------------------------------------
-// Set USE_RTC nonzero for file timestamps.
-// RAM use will be marginal on Uno with RTClib.
-// Set USE_RTC nonzero for file timestamps.
-// RAM use will be marginal on Uno with RTClib.
-// 0 - RTC not used
-// 1 - DS1307
-// 2 - DS3231
-// 3 - PCF8523
-#define USE_RTC 0
-#if USE_RTC
-#include "RTClib.h"
-#endif  // USE_RTC
-//------------------------------------------------------------------------------
-// Pin definitions.
-//
-// Digital pin to indicate an error, set to -1 if not used.
-// The led blinks for fatal errors. The led goes on solid for SD write
-// overrun errors and logging continues.
-const int8_t ERROR_LED_PIN = -1;
-
-// SD chip select pin.
-const uint8_t SD_CS_PIN = SS;
-//------------------------------------------------------------------------------
-// Analog pin number list for a sample.  Pins may be in any order and pin
-// numbers may be repeated.
-const uint8_t PIN_LIST[] = {0, 1, 2, 3, 4};
-//------------------------------------------------------------------------------
-// Sample rate in samples per second.
-const float SAMPLE_RATE = 5000;  // Must be 0.25 or greater.
-
-// The interval between samples in seconds, SAMPLE_INTERVAL, may be set to a
-// constant instead of being calculated from SAMPLE_RATE.  SAMPLE_RATE is not
-// used in the code below.  For example, setting SAMPLE_INTERVAL = 2.0e-4
-// will result in a 200 microsecond sample interval.
-const float SAMPLE_INTERVAL = 1.0/SAMPLE_RATE;
-
-// Setting ROUND_SAMPLE_INTERVAL non-zero will cause the sample interval to
-// be rounded to a a multiple of the ADC clock period and will reduce sample
-// time jitter.
-#define ROUND_SAMPLE_INTERVAL 1
-//------------------------------------------------------------------------------
-// Reference voltage.  See the processor data-sheet for reference details.
-// uint8_t const ADC_REF = 0; // External Reference AREF pin.
-uint8_t const ADC_REF = (1 << REFS0);  // Vcc Reference.
-// uint8_t const ADC_REF = (1 << REFS1);  // Internal 1.1 (only 644 1284P Mega)
-// uint8_t const ADC_REF = (1 << REFS1) | (1 << REFS0);  // Internal 1.1 or 2.56
-//------------------------------------------------------------------------------
-// File definitions.
-//
-// Maximum file size in bytes.
-// The program creates a contiguous file with MAX_FILE_SIZE_MiB bytes.
-// The file will be truncated if logging is stopped early.
-const uint32_t MAX_FILE_SIZE_MiB = 100;  // 100 MiB file.
-
-// log file name.  Integer field before dot will be incremented.
-#define LOG_FILE_NAME "AvrAdc00.bin"
-
-// Maximum length name including zero byte.
-const size_t NAME_DIM = 40;
-
-// Set RECORD_EIGHT_BITS non-zero to record only the high 8-bits of the ADC.
-#define RECORD_EIGHT_BITS 0
-//------------------------------------------------------------------------------
-// FIFO size definition. Use a multiple of 512 bytes for best performance.
-//
-#if RAMEND < 0X8FF
-#error SRAM too small
-#elif RAMEND < 0X10FF
-const size_t FIFO_SIZE_BYTES = 512;
-#elif RAMEND < 0X20FF
-const size_t FIFO_SIZE_BYTES = 4*512;
-#elif RAMEND < 0X40FF
-const size_t FIFO_SIZE_BYTES = 12*512;
-#else  // RAMEND
-const size_t FIFO_SIZE_BYTES = 16*512;
-#endif  // RAMEND
-//------------------------------------------------------------------------------
-// ADC clock rate.
-// The ADC clock rate is normally calculated from the pin count and sample
-// interval.  The calculation attempts to use the lowest possible ADC clock
-// rate.
-//
-// You can select an ADC clock rate by defining the symbol ADC_PRESCALER to
-// one of these values.  You must choose an appropriate ADC clock rate for
-// your sample interval.
-// #define ADC_PRESCALER 7 // F_CPU/128 125 kHz on an Uno
-// #define ADC_PRESCALER 6 // F_CPU/64  250 kHz on an Uno
-// #define ADC_PRESCALER 5 // F_CPU/32  500 kHz on an Uno
-// #define ADC_PRESCALER 4 // F_CPU/16 1000 kHz on an Uno
-// #define ADC_PRESCALER 3 // F_CPU/8  2000 kHz on an Uno (8-bit mode only)
-//==============================================================================
-// End of configuration constants.
-//==============================================================================
-// Temporary log file.  Will be deleted if a reset or power failure occurs.
-#define TMP_FILE_NAME "tmp_adc.bin"
-
-// Number of analog pins to log.
-const uint8_t PIN_COUNT = sizeof(PIN_LIST)/sizeof(PIN_LIST[0]);
-
-// Minimum ADC clock cycles per sample interval
-const uint16_t MIN_ADC_CYCLES = 15;
-
-// Extra cpu cycles to setup ADC with more than one pin per sample.
-const uint16_t ISR_SETUP_ADC = PIN_COUNT > 1 ? 100 : 0;
-
-// Maximum cycles for timer0 system interrupt.
-const uint16_t ISR_TIMER0 = 160;
-//==============================================================================
-const uint32_t MAX_FILE_SIZE = MAX_FILE_SIZE_MiB << 20;
-
-// Max SPI rate for AVR is 10 MHz for F_CPU 20 MHz, 8 MHz for F_CPU 16 MHz.
-#define SPI_CLOCK SD_SCK_MHZ(10)
-
-// Select fastest interface.
-#if ENABLE_DEDICATED_SPI
-#define SD_CONFIG SdSpiConfig(SD_CS_PIN, DEDICATED_SPI, SPI_CLOCK)
-#else  // ENABLE_DEDICATED_SPI
-#define SD_CONFIG SdSpiConfig(SD_CS_PIN, SHARED_SPI, SPI_CLOCK)
-#endif  // ENABLE_DEDICATED_SPI
-
-#if SD_FAT_TYPE == 0
-SdFat sd;
-typedef File file_t;
-#elif SD_FAT_TYPE == 1
-SdFat32 sd;
-typedef File32 file_t;
-#elif SD_FAT_TYPE == 2
-SdExFat sd;
-typedef ExFile file_t;
-#elif SD_FAT_TYPE == 3
-SdFs sd;
-typedef FsFile file_t;
-#else  // SD_FAT_TYPE
-#error Invalid SD_FAT_TYPE
-#endif  // SD_FAT_TYPE
-
-file_t binFile;
-file_t csvFile;
-
-char binName[] = LOG_FILE_NAME;
-
-#if RECORD_EIGHT_BITS
-const size_t BLOCK_MAX_COUNT = PIN_COUNT*(DATA_DIM8/PIN_COUNT);
-typedef block8_t block_t;
-#else  // RECORD_EIGHT_BITS
-const size_t BLOCK_MAX_COUNT = PIN_COUNT*(DATA_DIM16/PIN_COUNT);
-typedef block16_t block_t;
-#endif // RECORD_EIGHT_BITS
-
-// Size of FIFO in blocks.
-size_t const FIFO_DIM = FIFO_SIZE_BYTES/sizeof(block_t);
-block_t* fifoData;
-volatile size_t fifoCount = 0; // volatile - shared, ISR and background.
-size_t fifoHead = 0;  // Only accessed by ISR during logging.
-size_t fifoTail = 0;  // Only accessed by writer during logging.
-//==============================================================================
-// Interrupt Service Routines
-
-// Disable ADC interrupt if true.
-volatile bool isrStop = false;
-
-// Pointer to current buffer.
-block_t* isrBuf = nullptr;
-// overrun count
-uint16_t isrOver = 0;
-
-// ADC configuration for each pin.
-uint8_t adcmux[PIN_COUNT];
-uint8_t adcsra[PIN_COUNT];
-uint8_t adcsrb[PIN_COUNT];
-uint8_t adcindex = 1;
-
-// Insure no timer events are missed.
-volatile bool timerError = false;
-volatile bool timerFlag = false;
-//------------------------------------------------------------------------------
-// ADC done interrupt.
-ISR(ADC_vect) {
-  // Read ADC data.
-#if RECORD_EIGHT_BITS
-  uint8_t d = ADCH;
-#else  // RECORD_EIGHT_BITS
-  // This will access ADCL first.
-  uint16_t d = ADC;
-#endif  // RECORD_EIGHT_BITS
-
-  if (!isrBuf) {
-    if (fifoCount < FIFO_DIM) {
-      isrBuf = fifoData + fifoHead;
-    } else {
-      // no buffers - count overrun
-      if (isrOver < 0XFFFF) {
-        isrOver++;
-      }
-      // Avoid missed timer error.
-      timerFlag = false;
-      return;
-    }
-  }
-  // Start ADC for next pin
-  if (PIN_COUNT > 1) {
-    ADMUX = adcmux[adcindex];
-    ADCSRB = adcsrb[adcindex];
-    ADCSRA = adcsra[adcindex];
-    if (adcindex == 0) {
-      timerFlag = false;
-    }
-    adcindex =  adcindex < (PIN_COUNT - 1) ? adcindex + 1 : 0;
-  } else {
-    timerFlag = false;
-  }
-  // Store ADC data.
-  isrBuf->data[isrBuf->count++] = d;
-
-  // Check for buffer full.
-  if (isrBuf->count >= BLOCK_MAX_COUNT) {
-    fifoHead = fifoHead < (FIFO_DIM - 1) ? fifoHead + 1 : 0;
-    fifoCount++;
-    // Check for end logging.
-    if (isrStop) {
-      adcStop();
-      return;
-    }
-    // Set buffer needed and clear overruns.
-    isrBuf = nullptr;
-    isrOver = 0;
-  }
-}
-//------------------------------------------------------------------------------
-// timer1 interrupt to clear OCF1B
-ISR(TIMER1_COMPB_vect) {
-  // Make sure ADC ISR responded to timer event.
-  if (timerFlag) {
-    timerError = true;
-  }
-  timerFlag = true;
-}
-//==============================================================================
-// Error messages stored in flash.
-#define error(msg) (Serial.println(F(msg)),errorHalt())
-#define assert(e) ((e) ? (void)0 : error("assert: " #e))
-//------------------------------------------------------------------------------
-//
-void fatalBlink() {
-  while (true) {
-    if (ERROR_LED_PIN >= 0) {
-      digitalWrite(ERROR_LED_PIN, HIGH);
-      delay(200);
-      digitalWrite(ERROR_LED_PIN, LOW);
-      delay(200);
-    }
-  }
-}
-//------------------------------------------------------------------------------
-void errorHalt() {
-  // Print minimal error data.
-  // sd.errorPrint(&Serial);
-  // Print extended error info - uses extra bytes of flash.
-  sd.printSdError(&Serial);
-  // Try to save data.
-  binFile.close();
-  fatalBlink();
-}
-//------------------------------------------------------------------------------
-void printUnusedStack() {
-  Serial.print(F("\nUnused stack: "));
-  Serial.println(UnusedStack());
-}
-//------------------------------------------------------------------------------
-#if USE_RTC
-#if USE_RTC == 1
-RTC_DS1307 rtc;
-#elif USE_RTC == 2
-RTC_DS3231 rtc;
-#elif USE_RTC == 3
-RTC_PCF8523 rtc;
-#else  // USE_RTC == type
-#error USE_RTC type not implemented.
-#endif  // USE_RTC == type
-// Call back for file timestamps.  Only called for file create and sync().
-void dateTime(uint16_t* date, uint16_t* time, uint8_t* ms10) {
-  DateTime now = rtc.now();
-
-  // Return date using FS_DATE macro to format fields.
-  *date = FS_DATE(now.year(), now.month(), now.day());
-
-  // Return time using FS_TIME macro to format fields.
-  *time = FS_TIME(now.hour(), now.minute(), now.second());
-
-  // Return low time bits in units of 10 ms.
-  *ms10 = now.second() & 1 ? 100 : 0;
-}
-#endif  // USE_RTC
-//==============================================================================
-#if ADPS0 != 0 || ADPS1 != 1 || ADPS2 != 2
-#error unexpected ADC prescaler bits
-#endif
-//------------------------------------------------------------------------------
-inline bool adcActive() {return (1 << ADIE) & ADCSRA;}
-//------------------------------------------------------------------------------
-// initialize ADC and timer1
-void adcInit(metadata_t* meta) {
-  uint8_t adps;  // prescaler bits for ADCSRA
-  uint32_t ticks = F_CPU*SAMPLE_INTERVAL + 0.5;  // Sample interval cpu cycles.
-
-  if (ADC_REF & ~((1 << REFS0) | (1 << REFS1))) {
-    error("Invalid ADC reference");
-  }
-#ifdef ADC_PRESCALER
-  if (ADC_PRESCALER > 7 || ADC_PRESCALER < 2) {
-    error("Invalid ADC prescaler");
-  }
-  adps = ADC_PRESCALER;
-#else  // ADC_PRESCALER
-  // Allow extra cpu cycles to change ADC settings if more than one pin.
-  int32_t adcCycles = (ticks - ISR_TIMER0)/PIN_COUNT - ISR_SETUP_ADC;
-
-  for (adps = 7; adps > 0; adps--) {
-    if (adcCycles >= (MIN_ADC_CYCLES << adps)) {
-      break;
-    }
-  }
-#endif  // ADC_PRESCALER
-  meta->adcFrequency = F_CPU >> adps;
-  if (meta->adcFrequency > (RECORD_EIGHT_BITS ? 2000000 : 1000000)) {
-    error("Sample Rate Too High");
-  }
-#if ROUND_SAMPLE_INTERVAL
-  // Round so interval is multiple of ADC clock.
-  ticks += 1 << (adps - 1);
-  ticks >>= adps;
-  ticks <<= adps;
-#endif  // ROUND_SAMPLE_INTERVAL
-
-  if (PIN_COUNT > BLOCK_MAX_COUNT || PIN_COUNT > PIN_NUM_DIM) {
-    error("Too many pins");
-  }
-  meta->pinCount = PIN_COUNT;
-  meta->recordEightBits = RECORD_EIGHT_BITS;
-
-  for (int i = 0; i < PIN_COUNT; i++) {
-    uint8_t pin = PIN_LIST[i];
-    if (pin >= NUM_ANALOG_INPUTS) {
-      error("Invalid Analog pin number");
-    }
-    meta->pinNumber[i] = pin;
-
-    // Set ADC reference and low three bits of analog pin number.
-    adcmux[i] = (pin & 7) | ADC_REF;
-    if (RECORD_EIGHT_BITS) {
-      adcmux[i] |= 1 << ADLAR;
-    }
-
-    // If this is the first pin, trigger on timer/counter 1 compare match B.
-    adcsrb[i] = i == 0 ? (1 << ADTS2) | (1 << ADTS0) : 0;
-#ifdef MUX5
-    if (pin > 7) {
-      adcsrb[i] |= (1 << MUX5);
-    }
-#endif  // MUX5
-    adcsra[i] = (1 << ADEN) | (1 << ADIE) | adps;
-    // First pin triggers on timer 1 compare match B rest are free running.
-    adcsra[i] |= i == 0 ? 1 << ADATE : 1 << ADSC;
-  }
-
-  // Setup timer1
-  TCCR1A = 0;
-  uint8_t tshift;
-  if (ticks < 0X10000) {
-    // no prescale, CTC mode
-    TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS10);
-    tshift = 0;
-  } else if (ticks < 0X10000*8) {
-    // prescale 8, CTC mode
-    TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS11);
-    tshift = 3;
-  } else if (ticks < 0X10000*64) {
-    // prescale 64, CTC mode
-    TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS11) | (1 << CS10);
-    tshift = 6;
-  } else if (ticks < 0X10000*256) {
-    // prescale 256, CTC mode
-    TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS12);
-    tshift = 8;
-  } else if (ticks < 0X10000*1024) {
-    // prescale 1024, CTC mode
-    TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS12) | (1 << CS10);
-    tshift = 10;
-  } else {
-    error("Sample Rate Too Slow");
-  }
-  // divide by prescaler
-  ticks >>= tshift;
-  // set TOP for timer reset
-  ICR1 = ticks - 1;
-  // compare for ADC start
-  OCR1B = 0;
-
-  // multiply by prescaler
-  ticks <<= tshift;
-
-  // Sample interval in CPU clock ticks.
-  meta->sampleInterval = ticks;
-  meta->cpuFrequency = F_CPU;
-  float sampleRate = (float)meta->cpuFrequency/meta->sampleInterval;
-  Serial.print(F("Sample pins:"));
-  for (uint8_t i = 0; i < meta->pinCount; i++) {
-    Serial.print(' ');
-    Serial.print(meta->pinNumber[i], DEC);
-  }
-  Serial.println();
-  Serial.print(F("ADC bits: "));
-  Serial.println(meta->recordEightBits ? 8 : 10);
-  Serial.print(F("ADC clock kHz: "));
-  Serial.println(meta->adcFrequency/1000);
-  Serial.print(F("Sample Rate: "));
-  Serial.println(sampleRate);
-  Serial.print(F("Sample interval usec: "));
-  Serial.println(1000000.0/sampleRate);
-}
-//------------------------------------------------------------------------------
-// enable ADC and timer1 interrupts
-void adcStart() {
-  // initialize ISR
-  adcindex = 1;
-  isrBuf = nullptr;
-  isrOver = 0;
-  isrStop = false;
-
-  // Clear any pending interrupt.
-  ADCSRA |= 1 << ADIF;
-
-  // Setup for first pin.
-  ADMUX = adcmux[0];
-  ADCSRB = adcsrb[0];
-  ADCSRA = adcsra[0];
-
-  // Enable timer1 interrupts.
-  timerError = false;
-  timerFlag = false;
-  TCNT1 = 0;
-  TIFR1 = 1 << OCF1B;
-  TIMSK1 = 1 << OCIE1B;
-}
-//------------------------------------------------------------------------------
-inline void adcStop() {
-  TIMSK1 = 0;
-  ADCSRA = 0;
-}
-//------------------------------------------------------------------------------
-// Convert binary file to csv file.
-void binaryToCsv() {
-  uint8_t lastPct = 0;
-  block_t* pd;
-  metadata_t* pm;
-  uint32_t t0 = millis();
-  // Use fast buffered print class.
-  BufferedPrint<file_t, 64> bp(&csvFile);
-  block_t binBuffer[FIFO_DIM];
-
-  assert(sizeof(block_t) == sizeof(metadata_t));
-  binFile.rewind();
-  uint32_t tPct = millis();
-  bool doMeta = true;
-  while (!Serial.available()) {
-    pd = binBuffer;
-    int nb = binFile.read(binBuffer, sizeof(binBuffer));
-    if (nb < 0) {
-      error("read binFile failed");
-    }
-    size_t nd = nb/sizeof(block_t);
-    if (nd < 1) {
-      break;
-    }
-    if (doMeta) {
-      doMeta = false;
-      pm = (metadata_t*)pd++;
-      if (PIN_COUNT != pm->pinCount) {
-        error("Invalid pinCount");
-      }
-      bp.print(F("Interval,"));
-      float intervalMicros = 1.0e6*pm->sampleInterval/(float)pm->cpuFrequency;
-      bp.print(intervalMicros, 4);
-      bp.println(F(",usec"));
-      for (uint8_t i = 0; i < PIN_COUNT; i++) {
-        if (i) {
-          bp.print(',');
-        }
-        bp.print(F("pin"));
-        bp.print(pm->pinNumber[i]);
-      }
-      bp.println();
-      if (nd-- == 1) {
-        break;
-      }
-    }
-    for (size_t i = 0; i < nd; i++, pd++) {
-      if (pd->overrun) {
-        bp.print(F("OVERRUN,"));
-        bp.println(pd->overrun);
-      }
-      for (size_t j = 0; j < pd->count; j += PIN_COUNT) {
-        for (size_t i = 0; i < PIN_COUNT; i++) {
-          if (!bp.printField(pd->data[i + j], i == (PIN_COUNT-1) ? '\n' : ',')) {
-            error("printField failed");
-          }
-        }
-      }
-    }
-    if ((millis() - tPct) > 1000) {
-      uint8_t pct = binFile.curPosition()/(binFile.fileSize()/100);
-      if (pct != lastPct) {
-        tPct = millis();
-        lastPct = pct;
-        Serial.print(pct, DEC);
-        Serial.println('%');
-      }
-    }
-  }
-  if (!bp.sync() || !csvFile.close()) {
-    error("close csvFile failed");
-  }
-  Serial.print(F("Done: "));
-  Serial.print(0.001*(millis() - t0));
-  Serial.println(F(" Seconds"));
-}
-//------------------------------------------------------------------------------
-void clearSerialInput() {
-  uint32_t m = micros();
-  do {
-    if (Serial.read() >= 0) {
-      m = micros();
-    }
-  } while (micros() - m < 10000);
-}
-//------------------------------------------------------------------------------
-void createBinFile() {
-  binFile.close();
-  while (sd.exists(binName)) {
-    char* p = strchr(binName, '.');
-    if (!p) {
-      error("no dot in filename");
-    }
-    while (true) {
-      p--;
-      if (p < binName || *p < '0' || *p > '9') {
-        error("Can't create file name");
-      }
-      if (p[0] != '9') {
-        p[0]++;
-        break;
-      }
-      p[0] = '0';
-    }
-  }
-  Serial.print(F("Opening: "));
-  Serial.println(binName);
-  if (!binFile.open(binName, O_RDWR | O_CREAT)) {
-    error("open binName failed");
-  }
-  Serial.print(F("Allocating: "));
-  Serial.print(MAX_FILE_SIZE_MiB);
-  Serial.println(F(" MiB"));
-  if (!binFile.preAllocate(MAX_FILE_SIZE)) {
-    error("preAllocate failed");
-  }
-}
-//------------------------------------------------------------------------------
-bool createCsvFile() {
-  char csvName[NAME_DIM];
-
-  if (!binFile.isOpen()) {
-    Serial.println(F("No current binary file"));
-    return false;
-  }
-  binFile.getName(csvName, sizeof(csvName));
-  char* dot = strchr(csvName, '.');
-  if (!dot) {
-    error("no dot in binName");
-  }
-  strcpy(dot + 1, "csv");
-  if (!csvFile.open(csvName, O_WRONLY|O_CREAT|O_TRUNC)) {
-    error("open csvFile failed");
-  }
-  Serial.print(F("Writing: "));
-  Serial.print(csvName);
-  Serial.println(F(" - type any character to stop"));
-  return true;
-}
-//------------------------------------------------------------------------------
-// log data
-void logData() {
-  uint32_t t0;
-  uint32_t t1;
-  uint32_t overruns =0;
-  uint32_t count = 0;
-  uint32_t maxLatencyUsec = 0;
-  size_t maxFifoUse = 0;
-  block_t fifoBuffer[FIFO_DIM];
-
-  adcInit((metadata_t*)fifoBuffer);
-  // Write metadata.
-  if (sizeof(metadata_t) != binFile.write(fifoBuffer, sizeof(metadata_t))) {
-    error("Write metadata failed");
-  }
-  fifoCount = 0;
-  fifoHead = 0;
-  fifoTail = 0;
-  fifoData = fifoBuffer;
-  // Initialize all blocks to save ISR overhead.
-  memset(fifoBuffer, 0, sizeof(fifoBuffer));
-
-  Serial.println(F("Logging - type any character to stop"));
-  // Wait for Serial Idle.
-  Serial.flush();
-  delay(10);
-
-  t0 = millis();
-  t1 = t0;
-  // Start logging interrupts.
-  adcStart();
-  while (1) {
-    uint32_t m;
-    noInterrupts();
-    size_t tmpFifoCount = fifoCount;
-    interrupts();
-    if (tmpFifoCount) {
-      block_t* pBlock = fifoData + fifoTail;
-      // Write block to SD.
-      m = micros();
-      if (sizeof(block_t) != binFile.write(pBlock, sizeof(block_t))) {
-        error("write data failed");
-      }
-      m = micros() - m;
-      t1 = millis();
-      if (m > maxLatencyUsec) {
-        maxLatencyUsec = m;
-      }
-      if (tmpFifoCount >maxFifoUse) {
-        maxFifoUse = tmpFifoCount;
-      }
-      count += pBlock->count;
-
-      // Add overruns and possibly light LED.
-      if (pBlock->overrun) {
-        overruns += pBlock->overrun;
-        if (ERROR_LED_PIN >= 0) {
-          digitalWrite(ERROR_LED_PIN, HIGH);
-        }
-      }
-      // Initialize empty block to save ISR overhead.
-      pBlock->count = 0;
-      pBlock->overrun = 0;
-      fifoTail = fifoTail < (FIFO_DIM - 1) ? fifoTail + 1 : 0;
-
-      noInterrupts();
-      fifoCount--;
-      interrupts();
-
-      if (binFile.curPosition() >= MAX_FILE_SIZE) {
-        // File full so stop ISR calls.
-        adcStop();
-        break;
-      }
-    }
-    if (timerError) {
-      error("Missed timer event - rate too high");
-    }
-    if (Serial.available()) {
-      // Stop ISR interrupts.
-      isrStop = true;
-    }
-    if (fifoCount == 0 && !adcActive()) {
-       break;
-    }
-  }
-  Serial.println();
-  // Truncate file if recording stopped early.
-  if (binFile.curPosition() < MAX_FILE_SIZE) {
-    Serial.println(F("Truncating file"));
-    Serial.flush();
-    if (!binFile.truncate()) {
-      error("Can't truncate file");
-    }
-  }
-  Serial.print(F("Max write latency usec: "));
-  Serial.println(maxLatencyUsec);
-  Serial.print(F("Record time sec: "));
-  Serial.println(0.001*(t1 - t0), 3);
-  Serial.print(F("Sample count: "));
-  Serial.println(count/PIN_COUNT);
-  Serial.print(F("Overruns: "));
-  Serial.println(overruns);
-  Serial.print(F("FIFO_DIM: "));
-  Serial.println(FIFO_DIM);
-  Serial.print(F("maxFifoUse: "));
-  Serial.println(maxFifoUse + 1);  // include ISR use.
-  Serial.println(F("Done"));
-}
-//------------------------------------------------------------------------------
-void openBinFile() {
-  char name[NAME_DIM];
-  clearSerialInput();
-  Serial.println(F("Enter file name"));
-  if (!serialReadLine(name, sizeof(name))) {
-    return;
-  }
-  if (!sd.exists(name)) {
-    Serial.println(name);
-    Serial.println(F("File does not exist"));
-    return;
-  }
-  binFile.close();
-  if (!binFile.open(name, O_RDWR)) {
-    Serial.println(name);
-    Serial.println(F("open failed"));
-    return;
-  }
-  Serial.println(F("File opened"));
-}
-//------------------------------------------------------------------------------
-// Print data file to Serial
-void printData() {
-  block_t buf;
-  if (!binFile.isOpen()) {
-    Serial.println(F("No current binary file"));
-    return;
-  }
-  binFile.rewind();
-  if (binFile.read(&buf , sizeof(buf)) != sizeof(buf)) {
-    error("Read metadata failed");
-  }
-  Serial.println(F("Type any character to stop"));
-  delay(1000);
-  while (!Serial.available() &&
-         binFile.read(&buf , sizeof(buf)) == sizeof(buf)) {
-    if (buf.count == 0) {
-      break;
-    }
-    if (buf.overrun) {
-      Serial.print(F("OVERRUN,"));
-      Serial.println(buf.overrun);
-    }
-    for (size_t i = 0; i < buf.count; i++) {
-      Serial.print(buf.data[i], DEC);
-      if ((i+1)%PIN_COUNT) {
-        Serial.print(',');
-      } else {
-        Serial.println();
-      }
-    }
-  }
-  Serial.println(F("Done"));
-}
-//------------------------------------------------------------------------------
-bool serialReadLine(char* str, size_t size) {
-  size_t n = 0;
-  while(!Serial.available()) {
-  }
-  while (true) {
-    int c = Serial.read();
-    if (c < ' ') break;
-    str[n++] = c;
-    if (n >= size) {
-      Serial.println(F("input too long"));
-      return false;
-    }
-    uint32_t m = millis();
-    while (!Serial.available() && (millis() - m) < 100){}
-    if (!Serial.available()) break;
-  }
-  str[n] = 0;
-  return true;
-}
-//------------------------------------------------------------------------------
-void setup(void) {
-  if (ERROR_LED_PIN >= 0) {
-    pinMode(ERROR_LED_PIN, OUTPUT);
-  }
-  Serial.begin(9600);
-  while(!Serial) {}
-  Serial.println(F("Type any character to begin."));
-  while(!Serial.available()) {}
-
-  FillStack();
-
-  // Read the first sample pin to init the ADC.
-  analogRead(PIN_LIST[0]);
-
-#if !ENABLE_DEDICATED_SPI
-  Serial.println(F(
-    "\nFor best performance edit SdFatConfig.h\n"
-    "and set ENABLE_DEDICATED_SPI nonzero"));
-#endif  // !ENABLE_DEDICATED_SPI
-  // Initialize SD.
-  if (!sd.begin(SD_CONFIG)) {
-    error("sd.begin failed");
-  }
-#if USE_RTC
-  if (!rtc.begin()) {
-    error("rtc.begin failed");
-  }
-  if (!rtc.isrunning()) {
-    // Set RTC to sketch compile date & time.
-    // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
-    error("RTC is NOT running!");
-  } else {
-    Serial.println(F("RTC is running"));
-  }
-  // Set callback
-  FsDateTime::setCallback(dateTime);
-#endif  // USE_RTC
-}
-//------------------------------------------------------------------------------
-void loop(void) {
-  printUnusedStack();
-  // Read any Serial data.
-  clearSerialInput();
-  Serial.println();
-  Serial.println(F("type:"));
-  Serial.println(F("b - open existing bin file"));
-  Serial.println(F("c - convert file to csv"));
-  Serial.println(F("l - list files"));
-  Serial.println(F("p - print data to Serial"));
-  Serial.println(F("r - record ADC data"));
-
-  while(!Serial.available()) {
-    yield();
-  }
-  char c = tolower(Serial.read());
-  Serial.println();
-  if (ERROR_LED_PIN >= 0) {
-    digitalWrite(ERROR_LED_PIN, LOW);
-  }
-  // Read any Serial data.
-  clearSerialInput();
-
-  if (c == 'b') {
-    openBinFile();
-  } else if (c == 'c') {
-    if (createCsvFile()) {
-      binaryToCsv();
-    }
-  } else if (c == 'l') {
-    Serial.println(F("ls:"));
-    sd.ls(&Serial, LS_DATE | LS_SIZE);
-  } else if (c == 'p') {
-    printData();
-  } else if (c == 'r') {
-    createBinFile();
-    logData();
-  } else {
-    Serial.println(F("Invalid entry"));
-  }
-}
-#else  // __AVR__
-#error This program is only for AVR.
-#endif  // __AVR__

lib/SdFat_NoArduino/examples/SdInfo/SdInfo.ino

@@ -1,269 +0,0 @@
-/*
- * This program attempts to initialize an SD card and analyze its structure.
- */
-#include "SdFat.h"
-#include "sdios.h"
-/*
-  Set DISABLE_CS_PIN to disable a second SPI device.
-  For example, with the Ethernet shield, set DISABLE_CS_PIN
-  to 10 to disable the Ethernet controller.
-*/
-const int8_t DISABLE_CS_PIN = -1;
-/*
-  Change the value of SD_CS_PIN if you are using SPI
-  and your hardware does not use the default value, SS.
-  Common values are:
-  Arduino Ethernet shield: pin 4
-  Sparkfun SD shield: pin 8
-  Adafruit SD shields and modules: pin 10
-*/
-// SDCARD_SS_PIN is defined for the built-in SD on some boards.
-#ifndef SDCARD_SS_PIN
-const uint8_t SD_CS_PIN = SS;
-#else  // SDCARD_SS_PIN
-const uint8_t SD_CS_PIN = SDCARD_SS_PIN;
-#endif  // SDCARD_SS_PIN
-
-// Try to select the best SD card configuration.
-#if HAS_SDIO_CLASS
-#define SD_CONFIG SdioConfig(FIFO_SDIO)
-#elif ENABLE_DEDICATED_SPI
-#define SD_CONFIG SdSpiConfig(SD_CS_PIN, DEDICATED_SPI, SD_SCK_MHZ(16))
-#else  // HAS_SDIO_CLASS
-#define SD_CONFIG SdSpiConfig(SD_CS_PIN, SHARED_SPI, SD_SCK_MHZ(16))
-#endif  // HAS_SDIO_CLASS
-
-//------------------------------------------------------------------------------
-SdFs sd;
-cid_t cid;
-csd_t csd;
-scr_t scr;
-uint8_t cmd6Data[64];
-uint32_t eraseSize;
-uint32_t ocr;
-static ArduinoOutStream cout(Serial);
-//------------------------------------------------------------------------------
-void cidDmp() {
-  cout << F("\nManufacturer ID: ");
-  cout << uppercase << showbase << hex << int(cid.mid) << dec << endl;
-  cout << F("OEM ID: ") << cid.oid[0] << cid.oid[1] << endl;
-  cout << F("Product: ");
-  for (uint8_t i = 0; i < 5; i++) {
-    cout << cid.pnm[i];
-  }
-  cout << F("\nRevision: ") << cid.prvN() << '.' << cid.prvM() << endl;
-  cout << F("Serial number: ") << hex << cid.psn() << dec << endl;
-  cout << F("Manufacturing date: ");
-  cout << cid.mdtMonth() << '/' << cid.mdtYear() << endl;
-  cout << endl;
-}
-//------------------------------------------------------------------------------
-void clearSerialInput() {
-  uint32_t m = micros();
-  do {
-    if (Serial.read() >= 0) {
-      m = micros();
-    }
-  } while (micros() - m < 10000);
-}
-//------------------------------------------------------------------------------
-void csdDmp() {
-  eraseSize = csd.eraseSize();
-  cout << F("cardSize: ") << 0.000512 * csd.capacity();
-  cout << F(" MB (MB = 1,000,000 bytes)\n");
-
-  cout << F("flashEraseSize: ") << int(eraseSize) << F(" blocks\n");
-  cout << F("eraseSingleBlock: ");
-  if (csd.eraseSingleBlock()) {
-    cout << F("true\n");
-  } else {
-    cout << F("false\n");
-  }
-  cout << F("dataAfterErase: ");
-  if (scr.dataAfterErase()) {
-    cout << F("ones\n");
-  } else {
-    cout << F("zeros\n");
-  }
-}
-//------------------------------------------------------------------------------
-void errorPrint() {
-  if (sd.sdErrorCode()) {
-    cout << F("SD errorCode: ") << hex << showbase;
-    printSdErrorSymbol(&Serial, sd.sdErrorCode());
-    cout << F(" = ") << int(sd.sdErrorCode()) << endl;
-    cout << F("SD errorData = ") << int(sd.sdErrorData()) << dec << endl;
-  }
-}
-//------------------------------------------------------------------------------
-bool mbrDmp() {
-  MbrSector_t mbr;
-  bool valid = true;
-  if (!sd.card()->readSector(0, (uint8_t*)&mbr)) {
-    cout << F("\nread MBR failed.\n");
-    errorPrint();
-    return false;
-  }
-  cout << F("\nSD Partition Table\n");
-  cout << F("part,boot,bgnCHS[3],type,endCHS[3],start,length\n");
-  for (uint8_t ip = 1; ip < 5; ip++) {
-    MbrPart_t *pt = &mbr.part[ip - 1];
-    if ((pt->boot != 0 && pt->boot != 0X80) ||
-        getLe32(pt->relativeSectors) > csd.capacity()) {
-      valid = false;
-    }
-    cout << int(ip) << ',' << uppercase << showbase << hex;
-    cout << int(pt->boot) << ',';
-    for (int i = 0; i < 3; i++ ) {
-      cout << int(pt->beginCHS[i]) << ',';
-    }
-    cout << int(pt->type) << ',';
-    for (int i = 0; i < 3; i++ ) {
-      cout << int(pt->endCHS[i]) << ',';
-    }
-    cout << dec << getLe32(pt->relativeSectors) << ',';
-    cout << getLe32(pt->totalSectors) << endl;
-  }
-  if (!valid) {
-    cout << F("\nMBR not valid, assuming Super Floppy format.\n");
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-void dmpVol() {
-  cout << F("\nScanning FAT, please wait.\n");
-  int32_t freeClusterCount = sd.freeClusterCount();
-  if (sd.fatType() <= 32) {
-    cout << F("\nVolume is FAT") << int(sd.fatType()) << endl;
-  } else {
-    cout << F("\nVolume is exFAT\n");
-  }
-  cout << F("sectorsPerCluster: ") << sd.sectorsPerCluster() << endl;
-  cout << F("fatStartSector:    ") << sd.fatStartSector() << endl;
-  cout << F("dataStartSector:   ") << sd.dataStartSector() << endl;
-  cout << F("clusterCount:      ") << sd.clusterCount() << endl;  
-  cout << F("freeClusterCount:  ");
-  if (freeClusterCount >= 0) {
-    cout << freeClusterCount << endl;
-  } else {
-    cout << F("failed\n");
-    errorPrint();    
-  }
-}
-//------------------------------------------------------------------------------
-void printCardType() {
-
-  cout << F("\nCard type: ");
-
-  switch (sd.card()->type()) {
-    case SD_CARD_TYPE_SD1:
-      cout << F("SD1\n");
-      break;
-
-    case SD_CARD_TYPE_SD2:
-      cout << F("SD2\n");
-      break;
-
-    case SD_CARD_TYPE_SDHC:
-      if (csd.capacity() < 70000000) {
-        cout << F("SDHC\n");
-      } else {
-        cout << F("SDXC\n");
-      }
-      break;
-
-    default:
-      cout << F("Unknown\n");
-  }
-}
-//------------------------------------------------------------------------------
-void printConfig(SdSpiConfig config) {
-  if (DISABLE_CS_PIN < 0) {
-    cout << F(
-           "\nAssuming the SD is the only SPI device.\n"
-           "Edit DISABLE_CS_PIN to disable an SPI device.\n");
-  } else {
-    cout << F("\nDisabling SPI device on pin ");
-    cout << int(DISABLE_CS_PIN) << endl;
-    pinMode(DISABLE_CS_PIN, OUTPUT);
-    digitalWrite(DISABLE_CS_PIN, HIGH);
-  }
-  cout << F("\nAssuming the SD chip select pin is: ") << int(config.csPin);
-  cout << F("\nEdit SD_CS_PIN to change the SD chip select pin.\n");
-}
-//------------------------------------------------------------------------------
-void printConfig(SdioConfig config) {
-  (void)config;
-  cout << F("Assuming an SDIO interface.\n");
-}
-//-----------------------------------------------------------------------------
-void setup() {
-  Serial.begin(9600);
-  // Wait for USB Serial
-  while (!Serial) {
-    yield();
-  }
-  cout << F("SdFat version: ") << SD_FAT_VERSION_STR << endl;
-  printConfig(SD_CONFIG);
-
-}
-//------------------------------------------------------------------------------
-void loop() {
-  // Read any existing Serial data.
-  clearSerialInput();
-
-  // F stores strings in flash to save RAM
-  cout << F("\ntype any character to start\n");
-  while (!Serial.available()) {
-    yield();
-  }
-  uint32_t t = millis();
-  if (!sd.cardBegin(SD_CONFIG)) {
-    cout << F(
-           "\nSD initialization failed.\n"
-           "Do not reformat the card!\n"
-           "Is the card correctly inserted?\n"
-           "Is there a wiring/soldering problem?\n");
-    if (isSpi(SD_CONFIG)) {
-      cout << F(
-           "Is SD_CS_PIN set to the correct value?\n"
-           "Does another SPI device need to be disabled?\n"
-           );
-    }
-    errorPrint();
-    return;
-  }
-  t = millis() - t;
-  cout << F("init time: ") << dec << t << " ms" << endl;
-
-  if (!sd.card()->readCID(&cid) ||
-      !sd.card()->readCSD(&csd) ||
-      !sd.card()->readOCR(&ocr) ||
-      !sd.card()->readSCR(&scr)) {
-    cout << F("readInfo failed\n");
-    errorPrint();
-    return;
-  }
-  printCardType();
-  cout << F("sdSpecVer: ") << 0.01*scr.sdSpecVer() << endl;
-  cout << F("HighSpeedMode: ");
-  if (scr.sdSpecVer() &&
-    sd.card()->cardCMD6(0X00FFFFFF, cmd6Data) && (2 & cmd6Data[13])) {
-    cout << F("true\n");
-  } else {
-    cout << F("false\n");
-  }      
-  cidDmp();
-  csdDmp();
-  cout << F("\nOCR: ") << uppercase << showbase;
-  cout << hex << ocr << dec << endl;
-  if (!mbrDmp()) {
-    return;
-  }
-  if (!sd.volumeBegin()) {
-    cout << F("\nvolumeBegin failed. Is the card formatted?\n");
-    errorPrint();
-    return;
-  }
-  dmpVol();
-}

lib/SdFat_NoArduino/examples/bench/bench.ino

@@ -1,274 +0,0 @@
-/*
- * This program is a simple binary write/read benchmark.
- */
-#include "SdFat.h"
-#include "sdios.h"
-#include "FreeStack.h"
-
-// SD_FAT_TYPE = 0 for SdFat/File as defined in SdFatConfig.h,
-// 1 for FAT16/FAT32, 2 for exFAT, 3 for FAT16/FAT32 and exFAT.
-#define SD_FAT_TYPE 0
-/*
-  Change the value of SD_CS_PIN if you are using SPI and
-  your hardware does not use the default value, SS.
-  Common values are:
-  Arduino Ethernet shield: pin 4
-  Sparkfun SD shield: pin 8
-  Adafruit SD shields and modules: pin 10
-*/
-// SDCARD_SS_PIN is defined for the built-in SD on some boards.
-#ifndef SDCARD_SS_PIN
-const uint8_t SD_CS_PIN = SS;
-#else  // SDCARD_SS_PIN
-// Assume built-in SD is used.
-const uint8_t SD_CS_PIN = SDCARD_SS_PIN;
-#endif  // SDCARD_SS_PIN
-
-// Try max SPI clock for an SD. Reduce SPI_CLOCK if errors occur.
-#define SPI_CLOCK SD_SCK_MHZ(50)
-
-// Try to select the best SD card configuration.
-#if HAS_SDIO_CLASS
-#define SD_CONFIG SdioConfig(FIFO_SDIO)
-#elif  ENABLE_DEDICATED_SPI
-#define SD_CONFIG SdSpiConfig(SD_CS_PIN, DEDICATED_SPI, SPI_CLOCK)
-#else  // HAS_SDIO_CLASS
-#define SD_CONFIG SdSpiConfig(SD_CS_PIN, SHARED_SPI, SPI_CLOCK)
-#endif  // HAS_SDIO_CLASS
-
-// Set PRE_ALLOCATE true to pre-allocate file clusters.
-const bool PRE_ALLOCATE = true;
-
-// Set SKIP_FIRST_LATENCY true if the first read/write to the SD can
-// be avoid by writing a file header or reading the first record.
-const bool SKIP_FIRST_LATENCY = true;
-
-// Size of read/write.
-const size_t BUF_SIZE = 512;
-
-// File size in MB where MB = 1,000,000 bytes.
-const uint32_t FILE_SIZE_MB = 5;
-
-// Write pass count.
-const uint8_t WRITE_COUNT = 2;
-
-// Read pass count.
-const uint8_t READ_COUNT = 2;
-//==============================================================================
-// End of configuration constants.
-//------------------------------------------------------------------------------
-// File size in bytes.
-const uint32_t FILE_SIZE = 1000000UL*FILE_SIZE_MB;
-
-// Insure 4-byte alignment.
-uint32_t buf32[(BUF_SIZE + 3)/4];
-uint8_t* buf = (uint8_t*)buf32;
-
-#if SD_FAT_TYPE == 0
-SdFat sd;
-File file;
-#elif SD_FAT_TYPE == 1
-SdFat32 sd;
-File32 file;
-#elif SD_FAT_TYPE == 2
-SdExFat sd;
-ExFile file;
-#elif SD_FAT_TYPE == 3
-SdFs sd;
-FsFile file;
-#else  // SD_FAT_TYPE
-#error Invalid SD_FAT_TYPE
-#endif  // SD_FAT_TYPE
-
-// Serial output stream
-ArduinoOutStream cout(Serial);
-//------------------------------------------------------------------------------
-// Store error strings in flash to save RAM.
-#define error(s) sd.errorHalt(&Serial, F(s))
-//------------------------------------------------------------------------------
-void cidDmp() {
-  cid_t cid;
-  if (!sd.card()->readCID(&cid)) {
-    error("readCID failed");
-  }
-  cout << F("\nManufacturer ID: ");
-  cout << uppercase << showbase << hex << int(cid.mid) << dec << endl;
-  cout << F("OEM ID: ") << cid.oid[0] << cid.oid[1] << endl;
-  cout << F("Product: ");
-  for (uint8_t i = 0; i < 5; i++) {
-    cout << cid.pnm[i];
-  }
-  cout << F("\nRevision: ") << cid.prvN() << '.' << cid.prvM() << endl;
-  cout << F("Serial number: ") << hex << cid.psn() << dec << endl;
-  cout << F("Manufacturing date: ");
-  cout << cid.mdtMonth() << '/' << cid.mdtYear() << endl;
-  cout << endl;
-}
-//------------------------------------------------------------------------------
-void clearSerialInput() {
-  uint32_t m = micros();
-  do {
-    if (Serial.read() >= 0) {
-      m = micros();
-    }
-  } while (micros() - m < 10000);
-}
-//------------------------------------------------------------------------------
-void setup() {
-  Serial.begin(9600);
-
-  // Wait for USB Serial
-  while (!Serial) {
-    yield();
-  }
-  delay(1000);
-  cout << F("\nUse a freshly formatted SD for best performance.\n");
-  if (!ENABLE_DEDICATED_SPI) {
-    cout << F(
-      "\nSet ENABLE_DEDICATED_SPI nonzero in\n"
-      "SdFatConfig.h for best SPI performance.\n");
-  }
-  // use uppercase in hex and use 0X base prefix
-  cout << uppercase << showbase << endl;
-}
-//------------------------------------------------------------------------------
-void loop() {
-  float s;
-  uint32_t t;
-  uint32_t maxLatency;
-  uint32_t minLatency;
-  uint32_t totalLatency;
-  bool skipLatency;
-
-  // Discard any input.
-  clearSerialInput();
-
-  // F() stores strings in flash to save RAM
-  cout << F("Type any character to start\n");
-  while (!Serial.available()) {
-    yield();
-  }
-#if HAS_UNUSED_STACK
-  cout << F("FreeStack: ") << FreeStack() << endl;
-#endif  // HAS_UNUSED_STACK
-
-  if (!sd.begin(SD_CONFIG)) {
-    sd.initErrorHalt(&Serial);
-  }
-  if (sd.fatType() == FAT_TYPE_EXFAT) {
-    cout << F("Type is exFAT") << endl;
-  } else {
-    cout << F("Type is FAT") << int(sd.fatType()) << endl;
-  }
-
-  cout << F("Card size: ") << sd.card()->sectorCount()*512E-9;
-  cout << F(" GB (GB = 1E9 bytes)") << endl;
-
-  cidDmp();
-
-  // open or create file - truncate existing file.
-  if (!file.open("bench.dat", O_RDWR | O_CREAT | O_TRUNC)) {
-    error("open failed");
-  }
-
-  // fill buf with known data
-  if (BUF_SIZE > 1) {
-    for (size_t i = 0; i < (BUF_SIZE - 2); i++) {
-      buf[i] = 'A' + (i % 26);
-    }
-    buf[BUF_SIZE-2] = '\r';
-  }
-  buf[BUF_SIZE-1] = '\n';
-
-  cout << F("FILE_SIZE_MB = ") << FILE_SIZE_MB << endl;
-  cout << F("BUF_SIZE = ") << BUF_SIZE << F(" bytes\n");
-  cout << F("Starting write test, please wait.") << endl << endl;
-
-  // do write test
-  uint32_t n = FILE_SIZE/BUF_SIZE;
-  cout <<F("write speed and latency") << endl;
-  cout << F("speed,max,min,avg") << endl;
-  cout << F("KB/Sec,usec,usec,usec") << endl;
-  for (uint8_t nTest = 0; nTest < WRITE_COUNT; nTest++) {
-    file.truncate(0);
-    if (PRE_ALLOCATE) {
-      if (!file.preAllocate(FILE_SIZE)) {
-        error("preAllocate failed");
-      }
-    }
-    maxLatency = 0;
-    minLatency = 9999999;
-    totalLatency = 0;
-    skipLatency = SKIP_FIRST_LATENCY;
-    t = millis();
-    for (uint32_t i = 0; i < n; i++) {
-      uint32_t m = micros();
-      if (file.write(buf, BUF_SIZE) != BUF_SIZE) {
-        error("write failed");
-      }
-      m = micros() - m;
-      totalLatency += m;
-      if (skipLatency) {
-        // Wait until first write to SD, not just a copy to the cache.
-        skipLatency = file.curPosition() < 512;
-      } else {
-        if (maxLatency < m) {
-          maxLatency = m;
-        }
-        if (minLatency > m) {
-          minLatency = m;
-        }
-      }
-    }
-    file.sync();
-    t = millis() - t;
-    s = file.fileSize();
-    cout << s/t <<',' << maxLatency << ',' << minLatency;
-    cout << ',' << totalLatency/n << endl;
-  }
-  cout << endl << F("Starting read test, please wait.") << endl;
-  cout << endl <<F("read speed and latency") << endl;
-  cout << F("speed,max,min,avg") << endl;
-  cout << F("KB/Sec,usec,usec,usec") << endl;
-
-  // do read test
-  for (uint8_t nTest = 0; nTest < READ_COUNT; nTest++) {
-    file.rewind();
-    maxLatency = 0;
-    minLatency = 9999999;
-    totalLatency = 0;
-    skipLatency = SKIP_FIRST_LATENCY;
-    t = millis();
-    for (uint32_t i = 0; i < n; i++) {
-      buf[BUF_SIZE-1] = 0;
-      uint32_t m = micros();
-      int32_t nr = file.read(buf, BUF_SIZE);
-      if (nr != BUF_SIZE) {
-        error("read failed");
-      }
-      m = micros() - m;
-      totalLatency += m;
-      if (buf[BUF_SIZE-1] != '\n') {
-
-        error("data check error");
-      }
-      if (skipLatency) {
-        skipLatency = false;
-      } else {
-        if (maxLatency < m) {
-          maxLatency = m;
-        }
-        if (minLatency > m) {
-          minLatency = m;
-        }
-      }
-    }
-    s = file.fileSize();
-    t = millis() - t;
-    cout << s/t <<',' << maxLatency << ',' << minLatency;
-    cout << ',' << totalLatency/n << endl;
-  }
-  cout << endl << F("Done") << endl;
-  file.close();
-  sd.end();
-}

lib/SdFat_NoArduino/library.properties

@@ -1,11 +0,0 @@
-name=SdFat_NoArduino
-version=2.2.0
-license=MIT
-author=Bill Greiman <fat16lib@sbcglobal.net>
-maintainer=Bill Greiman <fat16lib@sbcglobal.net>
-sentence=Provides access to SD memory cards.
-paragraph=The SdFat library supports FAT16, FAT32, and exFAT file systems on Standard SD, SDHC, and SDXC cards.
-category=Data Storage
-url=https://github.com/greiman/SdFat
-repository=https://github.com/greiman/SdFat.git
-architectures=*

lib/SdFat_NoArduino/src/BufferedPrint.h

@@ -1,269 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef BufferedPrint_h
-#define BufferedPrint_h
-/**
- * \file
- * \brief Fast buffered print.
- */
-#include "common/FmtNumber.h"
-/**
- * \class BufferedPrint
- * \brief Fast buffered print template.
- */
-template<typename WriteClass, uint8_t BUF_DIM>
-class BufferedPrint {
- public:
-  BufferedPrint() : m_wr(nullptr), m_in(0) {}
-  /** BufferedPrint constructor.
-   * \param[in] wr Print destination.
-   */
-  explicit BufferedPrint(WriteClass* wr) : m_wr(wr), m_in(0) {}
-  /** Initialize the BuffedPrint class.
-   * \param[in] wr Print destination.
-   */
-  void begin(WriteClass* wr) {
-    m_wr = wr;
-    m_in = 0;
-  }
-  /** Flush the buffer - same as sync() with no status return. */
-  void flush() {sync();}
-  /** Print a character followed by a field terminator.
-   * \param[in] c character to print.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \return true for success or false if an error occurs.
-   */
-  size_t printField(char c, char term) {
-    char buf[3];
-    char* str = buf + sizeof(buf);
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    *--str = c;
-    return write(str, buf + sizeof(buf) - str);
-  }
-  /** Print a string stored in AVR flash followed by a field terminator.
-   * \param[in] fsh string to print.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \return true for success or false if an error occurs.
-   */
-  size_t printField(const __FlashStringHelper *fsh, char term) {
-#ifdef __AVR__
-    size_t rtn = 0;
-    PGM_P p = reinterpret_cast<PGM_P>(fsh);
-    char c;
-    while ((c = pgm_read_byte(p++))) {
-      if (!write(&c, 1)) {
-        return 0;
-      }
-      rtn++;
-    }
-    if (term) {
-      char buf[2];
-      char* str = buf + sizeof(buf);
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-      rtn += write(str, buf + sizeof(buf) - str);
-    }
-    return rtn;
-#else  // __AVR__
-    return printField(reinterpret_cast<const char *>(fsh), term);
-#endif  // __AVR__
-  }
-  /** Print a string followed by a field terminator.
-   * \param[in] str string to print.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \return true for success or false if an error occurs.
-   */
-  size_t printField(const char* str, char term) {
-    size_t rtn = write(str, strlen(str));
-    if (term) {
-      char buf[2];
-      char* ptr = buf + sizeof(buf);
-      *--ptr = term;
-      if (term == '\n') {
-        *--ptr = '\r';
-      }
-      rtn += write(ptr, buf + sizeof(buf) - ptr);
-    }
-    return rtn;
-  }
-  /** Print a double followed by a field terminator.
-   * \param[in] d The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return true for success or false if an error occurs.
-   */
-  size_t printField(double d, char term, uint8_t prec = 2) {
-    char buf[24];
-    char* str = buf + sizeof(buf);
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    str = fmtDouble(str, d, prec, false);
-    return write(str, buf + sizeof(buf) - str);
-  }
-  /** Print a float followed by a field terminator.
-   * \param[in] f The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return true for success or false if an error occurs.
-   */
-  size_t printField(float f, char term,  uint8_t prec = 2) {
-    return printField(static_cast<double>(f), term, prec);
-  }
-  /** Print an integer value for 8, 16, and 32 bit signed and unsigned types.
-   * \param[in] n The value to print.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \return true for success or false if an error occurs.
-   */
-  template<typename Type>
-  size_t printField(Type n, char term) {
-    const uint8_t DIM = sizeof(Type) <= 2 ? 8 : 13;
-    char buf[DIM];
-    char* str = buf + sizeof(buf);
-
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    Type p = n < 0 ? -n : n;
-    if (sizeof(Type) <= 2) {
-      str = fmtBase10(str, (uint16_t)p);
-    } else {
-      str = fmtBase10(str, (uint32_t)p);
-    }
-    if (n < 0) {
-      *--str = '-';
-    }
-    return write(str, buf + sizeof(buf) - str);
-  }
-  /** Print CR LF.
-   * \return true for success or false if an error occurs.
-   */
-  size_t println() {
-    char buf[2];
-    buf[0] = '\r';
-    buf[1] = '\n';
-    return write(buf, 2);
-  }
-  /** Print a double.
-   * \param[in] d The number to be printed.
-   * \param[in] prec Number of digits after decimal point.
-   * \return true for success or false if an error occurs.
-   */
-  size_t print(double d, uint8_t prec = 2) {
-    return printField(d, 0, prec);
-  }
-  /** Print a double followed by CR LF.
-   * \param[in] d The number to be printed.
-   * \param[in] prec Number of digits after decimal point.
-   * \return true for success or false if an error occurs.
-   */
-  size_t println(double d, uint8_t prec = 2) {
-    return printField(d, '\n', prec);
-  }
-  /** Print a float.
-   * \param[in] f The number to be printed.
-   * \param[in] prec Number of digits after decimal point.
-   * \return true for success or false if an error occurs.
-   */
-  size_t print(float f, uint8_t prec = 2) {
-    return printField(static_cast<double>(f), 0, prec);
-  }
-  /** Print a float followed by CR LF.
-   * \param[in] f The number to be printed.
-   * \param[in] prec Number of digits after decimal point.
-   * \return true for success or false if an error occurs.
-   */
-  size_t println(float f, uint8_t prec) {
-    return printField(static_cast<double>(f), '\n', prec);
-  }
-  /** Print character, string, or number.
-   * \param[in] v item to print.
-   * \return true for success or false if an error occurs.
-   */
-  template<typename Type>
-  size_t print(Type v) {
-    return printField(v, 0);
-  }
-  /** Print character, string, or number followed by CR LF.
-   * \param[in] v item to print.
-   * \return true for success or false if an error occurs.
-   */
-  template<typename Type>
-  size_t println(Type v) {
-    return printField(v, '\n');
-  }
-
-  /** Flush the buffer.
-   * \return true for success or false if an error occurs.
-   */
-  bool sync() {
-    if (!m_wr || m_wr->write(m_buf, m_in) != m_in) {
-      return false;
-    }
-    m_in = 0;
-    return true;
-  }
- /** Write data to an open file.
-   * \param[in] src Pointer to the location of the data to be written.
-   *
-   * \param[in] n Number of bytes to write.
-   *
-   * \return For success write() returns the number of bytes written, always
-   * \a n.
-   */
-  size_t write(const void* src, size_t n) {
-    if ((m_in + n) > sizeof(m_buf)) {
-      if (!sync()) {
-        return 0;
-      }
-      if (n >= sizeof(m_buf)) {
-        return n == m_wr->write((const uint8_t*)src, n) ? n : 0;
-      }
-    }
-    memcpy(m_buf + m_in, src, n);
-    m_in += n;
-    return n;
-  }
-
- private:
-  WriteClass* m_wr;
-  uint8_t m_in;
-  // Insure room for double.
-  uint8_t m_buf[BUF_DIM < 24 ? 24 : BUF_DIM];  // NOLINT
-};
-#endif  // BufferedPrint_h

lib/SdFat_NoArduino/src/ExFatLib/ExFatConfig.h

@@ -1,33 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef ExFatConfig_h
-#define ExFatConfig_h
-#include "SdFatConfig.h"
-
-#ifndef EXFAT_READ_ONLY
-#define EXFAT_READ_ONLY 0
-#endif  // EXFAT_READ_ONLY
-
-#endif  // ExFatConfig_h

lib/SdFat_NoArduino/src/ExFatLib/ExFatDbg.cpp

@@ -1,621 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "ExFatVolume.h"
-#include "../common/upcase.h"
-#include "ExFatLib.h"
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-//------------------------------------------------------------------------------
-static void printHex(print_t* pr, uint8_t h);
-static void printHex(print_t* pr, uint16_t val);
-static void printHex(print_t* pr, uint32_t val);
-static void printHex64(print_t* pr, uint64_t n);
-static void println64(print_t* pr, uint64_t n);
-//------------------------------------------------------------------------------
-static void dmpDirData(print_t* pr, DirGeneric_t* dir) {
-  for (uint8_t k = 0; k < 31; k++) {
-    if (k) {
-      pr->write(' ');
-    }
-    printHex(pr, dir->data[k]);
-  }
-  pr->println();
-}
-//------------------------------------------------------------------------------
-static uint16_t exFatDirChecksum(const void* dir, uint16_t checksum) {
-  const uint8_t* data = reinterpret_cast<const uint8_t*>(dir);
-  bool skip = data[0] == EXFAT_TYPE_FILE;
-  for (size_t i = 0; i < 32; i += (i == 1 && skip ? 3 : 1)) {
-    checksum = ((checksum << 15) | (checksum >> 1)) + data[i];
-  }
-  return checksum;
-}
-
-//------------------------------------------------------------------------------
-static uint16_t hashDir(DirName_t* dir, uint16_t hash) {
-  for (uint8_t i = 0; i < 30; i += 2) {
-    uint16_t u = getLe16(dir->unicode + i);
-    if (!u) {
-      break;
-    }
-  uint16_t c = toUpcase(u);
-  hash = ((hash << 15) | (hash >> 1)) + (c & 0XFF);
-  hash = ((hash << 15) | (hash >> 1)) + (c >> 8);
-  }
-  return hash;
-}
-//------------------------------------------------------------------------------
-static void printDateTime(print_t* pr,
-                          uint32_t timeDate, uint8_t ms, int8_t tz) {
-  fsPrintDateTime(pr, timeDate, ms, tz);
-  pr->println();
-}
-//------------------------------------------------------------------------------
-static void printDirBitmap(print_t* pr, DirBitmap_t* dir) {
-  pr->print(F("dirBitmap: 0x"));
-  pr->println(dir->type, HEX);
-  pr->print(F("flags: 0x"));
-  pr->println(dir->flags, HEX);
-  pr->print(F("firstCluster: "));
-  pr->println(getLe32(dir->firstCluster));
-  pr->print(F("size: "));
-  println64(pr, getLe64(dir->size));
-}
-//------------------------------------------------------------------------------
-static void printDirFile(print_t* pr, DirFile_t* dir) {
-  pr->print(F("dirFile: 0x"));
-  pr->println(dir->type, HEX);
-  pr->print(F("setCount: "));
-  pr->println(dir->setCount);
-  pr->print(F("setChecksum: 0x"));
-  pr->println(getLe16(dir->setChecksum), HEX);
-  pr->print(F("attributes: 0x"));
-  pr->println(getLe16(dir->attributes), HEX);
-  pr->print(F("createTime: "));
-  printDateTime(pr, getLe32(dir->createTime),
-                dir->createTimeMs, dir->createTimezone);
-  pr->print(F("modifyTime: "));
-  printDateTime(pr, getLe32(dir->modifyTime),
-                dir->modifyTimeMs, dir->modifyTimezone);
-  pr->print(F("accessTime: "));
-  printDateTime(pr, getLe32(dir->accessTime), 0, dir->accessTimezone);
-}
-//------------------------------------------------------------------------------
-static void printDirLabel(print_t* pr, DirLabel_t* dir) {
-  pr->print(F("dirLabel: 0x"));
-  pr->println(dir->type, HEX);
-  pr->print(F("labelLength: "));
-  pr->println(dir->labelLength);
-  pr->print(F("unicode: "));
-  for (size_t i = 0; i < dir->labelLength; i++) {
-    pr->write(dir->unicode[2*i]);
-  }
-  pr->println();
-}
-//------------------------------------------------------------------------------
-static void printDirName(print_t* pr, DirName_t* dir) {
-  pr->print(F("dirName: 0x"));
-  pr->println(dir->type, HEX);
-  pr->print(F("unicode: "));
-  for (size_t i = 0; i < 30; i += 2) {
-    uint16_t c = getLe16(dir->unicode + i);
-    if (c == 0) break;
-    if (c < 128) {
-      pr->print(static_cast<char>(c));
-    } else {
-      pr->print("0x");
-      pr->print(c, HEX);
-    }
-    pr->print(' ');
-  }
-  pr->println();
-}
-//------------------------------------------------------------------------------
-static void printDirStream(print_t* pr, DirStream_t* dir) {
-  pr->print(F("dirStream: 0x"));
-  pr->println(dir->type, HEX);
-  pr->print(F("flags: 0x"));
-  pr->println(dir->flags, HEX);
-  pr->print(F("nameLength: "));
-  pr->println(dir->nameLength);
-  pr->print(F("nameHash: 0x"));
-  pr->println(getLe16(dir->nameHash), HEX);
-  pr->print(F("validLength: "));
-  println64(pr, getLe64(dir->validLength));
-  pr->print(F("firstCluster: "));
-  pr->println(getLe32(dir->firstCluster));
-  pr->print(F("dataLength: "));
-  println64(pr, getLe64(dir->dataLength));
-}
-//------------------------------------------------------------------------------
-static void printDirUpcase(print_t* pr, DirUpcase_t* dir) {
-  pr->print(F("dirUpcase: 0x"));
-  pr->println(dir->type, HEX);
-    pr->print(F("checksum: 0x"));
-  pr->println(getLe32(dir->checksum), HEX);
-  pr->print(F("firstCluster: "));
-  pr->println(getLe32(dir->firstCluster));
-  pr->print(F("size: "));
-  println64(pr, getLe64(dir->size));
-}
-//------------------------------------------------------------------------------
-static void printExFatBoot(print_t* pr, pbs_t* pbs) {
-  BpbExFat_t* ebs = reinterpret_cast<BpbExFat_t*>(pbs->bpb);
-  pr->print(F("bpbSig: 0x"));
-  pr->println(getLe16(pbs->signature), HEX);
-  pr->print(F("FileSystemName: "));
-  pr->write(reinterpret_cast<uint8_t*>(pbs->oemName), 8);
-  pr->println();
-  for (size_t i = 0; i < sizeof(ebs->mustBeZero); i++) {
-    if (ebs->mustBeZero[i]) {
-      pr->println(F("mustBeZero error"));
-      break;
-    }
-  }
-  pr->print(F("PartitionOffset: 0x"));
-  printHex64(pr, getLe64(ebs->partitionOffset));
-  pr->print(F("VolumeLength: "));
-  println64(pr, getLe64(ebs->volumeLength));
-  pr->print(F("FatOffset: 0x"));
-  pr->println(getLe32(ebs->fatOffset), HEX);
-  pr->print(F("FatLength: "));
-  pr->println(getLe32(ebs->fatLength));
-  pr->print(F("ClusterHeapOffset: 0x"));
-  pr->println(getLe32(ebs->clusterHeapOffset), HEX);
-  pr->print(F("ClusterCount: "));
-  pr->println(getLe32(ebs->clusterCount));
-  pr->print(F("RootDirectoryCluster: "));
-  pr->println(getLe32(ebs->rootDirectoryCluster));
-  pr->print(F("VolumeSerialNumber: 0x"));
-  pr->println(getLe32(ebs->volumeSerialNumber), HEX);
-  pr->print(F("FileSystemRevision: 0x"));
-  pr->println(getLe32(ebs->fileSystemRevision), HEX);
-  pr->print(F("VolumeFlags: 0x"));
-  pr->println(getLe16(ebs->volumeFlags) , HEX);
-  pr->print(F("BytesPerSectorShift: "));
-  pr->println(ebs->bytesPerSectorShift);
-  pr->print(F("SectorsPerClusterShift: "));
-  pr->println(ebs->sectorsPerClusterShift);
-  pr->print(F("NumberOfFats: "));
-  pr->println(ebs->numberOfFats);
-  pr->print(F("DriveSelect: 0x"));
-  pr->println(ebs->driveSelect, HEX);
-  pr->print(F("PercentInUse: "));
-  pr->println(ebs->percentInUse);
-}
-//------------------------------------------------------------------------------
-static void printHex(print_t* pr, uint8_t h) {
-  if (h < 16) {
-    pr->write('0');
-  }
-  pr->print(h, HEX);
-}
-//------------------------------------------------------------------------------
-static void printHex(print_t* pr, uint16_t val) {
-  bool space = true;
-  for (uint8_t i = 0; i < 4; i++) {
-    uint8_t h = (val >> (12 - 4*i)) & 15;
-    if (h || i == 3) {
-      space = false;
-    }
-    if (space) {
-      pr->write(' ');
-    } else {
-      pr->print(h, HEX);
-    }
-  }
-}
-//------------------------------------------------------------------------------
-static void printHex(print_t* pr, uint32_t val) {
-  bool space = true;
-  for (uint8_t i = 0; i < 8; i++) {
-    uint8_t h = (val >> (28 - 4*i)) & 15;
-    if (h || i == 7) {
-      space = false;
-    }
-    if (space) {
-      pr->write(' ');
-    } else {
-      pr->print(h, HEX);
-    }
-  }
-}
-//------------------------------------------------------------------------------
-static void printHex64(print_t* pr, uint64_t n) {
-  char buf[17];
-  char *str = &buf[sizeof(buf) - 1];
-  *str = '\0';
-  do {
-    uint8_t h = n & 15;
-    *--str = h < 10 ? h + '0' : h + 'A' - 10;
-    n >>= 4;
-  } while (n);
-  pr->println(str);
-}
-//------------------------------------------------------------------------------
-static void println64(print_t* pr, uint64_t n) {
-  char buf[21];
-  char *str = &buf[sizeof(buf) - 1];
-  *str = '\0';
-  do {
-    uint64_t m = n;
-    n /= 10;
-    *--str = m - 10*n + '0';
-  } while (n);
-  pr->println(str);
-}
-//------------------------------------------------------------------------------
-static void printMbr(print_t* pr, MbrSector_t* mbr) {
-  pr->print(F("mbrSig: 0x"));
-  pr->println(getLe16(mbr->signature), HEX);
-  for (int i = 0; i < 4; i++) {
-    printHex(pr, mbr->part[i].boot);
-    pr->write(' ');
-    for (int k = 0; k < 3; k++) {
-      printHex(pr, mbr->part[i].beginCHS[k]);
-      pr->write(' ');
-    }
-    printHex(pr, mbr->part[i].type);
-    pr->write(' ');
-    for (int k = 0; k < 3; k++) {
-      printHex(pr, mbr->part[i].endCHS[k]);
-      pr->write(' ');
-    }
-    pr->print(getLe32(mbr->part[i].relativeSectors), HEX);
-    pr->print(' ');
-    pr->println(getLe32(mbr->part[i].totalSectors), HEX);
-  }
-}
-//==============================================================================
-void ExFatPartition::checkUpcase(print_t* pr) {
-  bool skip = false;
-  uint16_t u = 0;
-  uint8_t* upcase = nullptr;
-  uint32_t size = 0;
-  uint32_t sector = clusterStartSector(m_rootDirectoryCluster);
-  uint8_t* cache = dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
-  if (!cache) {
-    pr->println(F("read root failed"));
-    return;
-  }
-  DirUpcase_t* dir = reinterpret_cast<DirUpcase_t*>(cache);
-
-  pr->println(F("\nChecking upcase table"));
-  for (size_t i = 0; i < 16; i++) {
-    if (dir[i].type == EXFAT_TYPE_UPCASE) {
-      sector = clusterStartSector(getLe32(dir[i].firstCluster));
-      size = getLe64(dir[i].size);
-      break;
-    }
-  }
-  if (!size) {
-    pr->println(F("upcase not found"));
-    return;
-  }
-  for (size_t i = 0; i < size/2; i++) {
-    if ((i%256) == 0) {
-      upcase = dataCachePrepare(sector++, FsCache::CACHE_FOR_READ);
-      if (!upcase) {
-        pr->println(F("read upcase failed"));
-        return;
-      }
-    }
-    uint16_t v = getLe16(&upcase[2*(i & 0XFF)]);
-    if (skip) {
-      pr->print("skip ");
-      pr->print(u);
-      pr->write(' ');
-      pr->println(v);
-    }
-    if (v == 0XFFFF) {
-      skip = true;
-    } else if (skip) {
-      for (uint16_t k = 0; k < v; k++) {
-        uint16_t x = toUpcase(u + k);
-        if (x != (u + k)) {
-          printHex(pr, (uint16_t)(u+k));
-          pr->write(',');
-          printHex(pr, x);
-          pr->println("<<<<<<<<<<<<<<<<<<<<");
-        }
-      }
-      u += v;
-      skip = false;
-    } else {
-      uint16_t x = toUpcase(u);
-      if (v != x) {
-        printHex(pr, u);
-        pr->write(',');
-        printHex(pr, x);
-        pr->write(',');
-        printHex(pr, v);
-        pr->println();
-      }
-      u++;
-    }
-  }
-  pr->println(F("Done checkUpcase"));
-}
-//------------------------------------------------------------------------------
-void ExFatPartition::dmpBitmap(print_t* pr) {
-  pr->println(F("bitmap:"));
-  dmpSector(pr, m_clusterHeapStartSector);
-}
-//------------------------------------------------------------------------------
-void ExFatPartition::dmpCluster(print_t* pr, uint32_t cluster,
-                                uint32_t offset, uint32_t count) {
-  uint32_t sector = clusterStartSector(cluster) + offset;
-  for (uint32_t i = 0; i < count; i++) {
-    pr->print(F("\nSector: "));
-    pr->println(sector + i, HEX);
-    dmpSector(pr, sector + i);
-  }
-}
-//------------------------------------------------------------------------------
-void ExFatPartition::dmpFat(print_t* pr, uint32_t start, uint32_t count) {
-  uint32_t sector = m_fatStartSector + start;
-  uint32_t cluster = 128*start;
-  pr->println(F("FAT:"));
-  for (uint32_t i = 0; i < count; i++) {
-    uint8_t* cache = dataCachePrepare(sector + i, FsCache::CACHE_FOR_READ);
-    if (!cache) {
-      pr->println(F("cache read failed"));
-      return;
-    }
-    uint32_t* fat = reinterpret_cast<uint32_t*>(cache);
-    for (size_t k = 0; k < 128; k++) {
-      if (0 == cluster%8) {
-        if (k) {
-          pr->println();
-        }
-        printHex(pr, cluster);
-      }
-      cluster++;
-      pr->write(' ');
-      printHex(pr, fat[k]);
-    }
-    pr->println();
-  }
-}
-//------------------------------------------------------------------------------
-void ExFatPartition::dmpSector(print_t* pr, uint32_t sector) {
-  uint8_t* cache = dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
-  if (!cache) {
-    pr->println(F("dmpSector failed"));
-    return;
-  }
-  for (uint16_t i = 0; i < m_bytesPerSector; i++) {
-    if (i%32 == 0) {
-      if (i) {
-        pr->println();
-      }
-      printHex(pr, i);
-    }
-    pr->write(' ');
-    printHex(pr, cache[i]);
-  }
-  pr->println();
-}
-//------------------------------------------------------------------------------
-bool ExFatPartition::printDir(print_t* pr, ExFatFile* file) {
-  DirGeneric_t* dir = nullptr;
-  DirFile_t* dirFile;
-  DirStream_t* dirStream;
-  DirName_t* dirName;
-  uint16_t calcHash = 0;
-  uint16_t nameHash = 0;
-  uint16_t setChecksum = 0;
-  uint16_t calcChecksum = 0;
-  uint8_t  nameLength = 0;
-  uint8_t  setCount = 0;
-  uint8_t  nUnicode;
-
-#define RAW_ROOT
-#ifndef RAW_ROOT
-  while (1) {
-    uint8_t buf[FS_DIR_SIZE];
-    if (file->read(buf, FS_DIR_SIZE) != FS_DIR_SIZE) {
-      break;
-    }
-    dir = reinterpret_cast<DirGeneric_t*>(buf);
-#else  // RAW_ROOT
-  (void)file;
-  uint32_t nDir = 1UL << (m_sectorsPerClusterShift + 4);
-  uint32_t sector = clusterStartSector(m_rootDirectoryCluster);
-  for (uint32_t iDir = 0; iDir < nDir; iDir++) {
-    size_t i = iDir%16;
-    if (i == 0) {
-      uint8_t* cache = dataCachePrepare(sector++, FsCache::CACHE_FOR_READ);
-      if (!cache) {
-        return false;
-      }
-      dir = reinterpret_cast<DirGeneric_t*>(cache);
-    } else {
-      dir++;
-    }
-#endif  // RAW_ROOT
-    if (dir->type == EXFAT_TYPE_END_DIR) {
-      break;
-    }
-    pr->println();
-
-    switch (dir->type) {
-      case EXFAT_TYPE_BITMAP:
-        printDirBitmap(pr, reinterpret_cast<DirBitmap_t*>(dir));
-        break;
-
-      case EXFAT_TYPE_UPCASE:
-        printDirUpcase(pr, reinterpret_cast<DirUpcase_t*>(dir));
-        break;
-
-      case EXFAT_TYPE_LABEL:
-        printDirLabel(pr, reinterpret_cast<DirLabel_t*>(dir));
-        break;
-
-      case EXFAT_TYPE_FILE:
-        dirFile = reinterpret_cast<DirFile_t*>(dir);
-        printDirFile(pr, dirFile);
-        setCount = dirFile->setCount;
-        setChecksum = getLe16(dirFile->setChecksum);
-        calcChecksum = exFatDirChecksum(dir, 0);
-        break;
-
-      case EXFAT_TYPE_STREAM:
-        dirStream = reinterpret_cast<DirStream_t*>(dir);
-        printDirStream(pr, dirStream);
-        nameLength = dirStream->nameLength;
-        nameHash = getLe16(dirStream->nameHash);
-        calcChecksum = exFatDirChecksum(dir, calcChecksum);
-        setCount--;
-        calcHash = 0;
-        break;
-
-       case EXFAT_TYPE_NAME:
-        dirName = reinterpret_cast<DirName_t*>(dir);
-        printDirName(pr, dirName);
-        calcChecksum = exFatDirChecksum(dir, calcChecksum);
-        nUnicode = nameLength > 15 ? 15 : nameLength;
-        calcHash = hashDir(dirName, calcHash);
-        nameLength -= nUnicode;
-        setCount--;
-        if (nameLength == 0  || setCount == 0) {
-          pr->print(F("setChecksum: 0x"));
-          pr->print(setChecksum, HEX);
-          if (setChecksum != calcChecksum) {
-            pr->print(F(" != calcChecksum: 0x"));
-          } else {
-            pr->print(F(" == calcChecksum: 0x"));
-          }
-          pr->println(calcChecksum, HEX);
-          pr->print(F("nameHash: 0x"));
-          pr->print(nameHash, HEX);
-          if (nameHash != calcHash) {
-            pr->print(F(" != calcHash: 0x"));
-          } else {
-            pr->print(F(" == calcHash: 0x"));
-          }
-          pr->println(calcHash, HEX);
-        }
-        break;
-
-      default:
-        if (dir->type & EXFAT_TYPE_USED) {
-          pr->print(F("Unknown dirType: 0x"));
-        } else {
-          pr->print(F("Unused dirType: 0x"));
-        }
-        pr->println(dir->type, HEX);
-        dmpDirData(pr, dir);
-        break;
-    }
-  }
-  pr->println(F("Done"));
-  return true;
-}
-//------------------------------------------------------------------------------
-void ExFatPartition::printFat(print_t* pr) {
-  uint32_t next;
-  int8_t status;
-  pr->println(F("FAT:"));
-  for (uint32_t cluster = 0; cluster < 16; cluster++) {
-    status = fatGet(cluster, &next);
-    pr->print(cluster, HEX);
-    pr->write(' ');
-    if (status == 0) {
-      next = EXFAT_EOC;
-    }
-    pr->println(next, HEX);
-  }
-}
-//------------------------------------------------------------------------------
-void ExFatPartition::printUpcase(print_t* pr) {
-  uint8_t* upcase = nullptr;
-  uint32_t sector;
-  uint32_t size = 0;
-  uint32_t checksum = 0;
-  DirUpcase_t* dir;
-  sector = clusterStartSector(m_rootDirectoryCluster);
-  upcase = dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
-  dir = reinterpret_cast<DirUpcase_t*>(upcase);
-  if (!dir) {
-    pr->println(F("read root dir failed"));
-    return;
-  }
-  for (size_t i = 0; i < 16; i++) {
-    if (dir[i].type == EXFAT_TYPE_UPCASE) {
-      sector = clusterStartSector(getLe32(dir[i].firstCluster));
-      size = getLe64(dir[i].size);
-      break;
-    }
-  }
-  if (!size) {
-    pr->println(F("upcase not found"));
-    return;
-  }
-  for (uint16_t i = 0; i < size/2; i++) {
-    if ((i%256) == 0) {
-      upcase = dataCachePrepare(sector++, FsCache::CACHE_FOR_READ);
-      if (!upcase) {
-        pr->println(F("read upcase failed"));
-        return;
-      }
-    }
-    if (i%16 == 0) {
-      pr->println();
-      printHex(pr, i);
-    }
-    pr->write(' ');
-    uint16_t uc = getLe16(&upcase[2*(i & 0XFF)]);
-    printHex(pr, uc);
-    checksum = upcaseChecksum(uc, checksum);
-  }
-  pr->println();
-  pr->print(F("checksum: "));
-  printHex(pr, checksum);
-  pr->println();
-}
-//------------------------------------------------------------------------------
-bool ExFatPartition::printVolInfo(print_t* pr) {
-  uint8_t* cache = dataCachePrepare(0, FsCache::CACHE_FOR_READ);
-  if (!cache) {
-    pr->println(F("read mbr failed"));
-    return false;
-  }
-  MbrSector_t* mbr = reinterpret_cast<MbrSector_t*>(cache);
-  printMbr(pr, mbr);
-  uint32_t volStart = getLe32(mbr->part->relativeSectors);
-  uint32_t volSize = getLe32(mbr->part->totalSectors);
-  if (volSize == 0) {
-    pr->print(F("bad partition size"));
-    return false;
-  }
-  cache = dataCachePrepare(volStart, FsCache::CACHE_FOR_READ);
-  if (!cache) {
-    pr->println(F("read pbs failed"));
-    return false;
-  }
-  printExFatBoot(pr, reinterpret_cast<pbs_t*>(cache));
-  return true;
-}
-#endif  // DOXYGEN_SHOULD_SKIP_THIS

lib/SdFat_NoArduino/src/ExFatLib/ExFatFile.cpp

@@ -1,738 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "ExFatFile.cpp"
-#include "../common/DebugMacros.h"
-#include "../common/FsUtf.h"
-#include "ExFatLib.h"
-//------------------------------------------------------------------------------
-/** test for legal character.
- *
- * \param[in] c character to be tested.
- *
- * \return true for legal character else false.
- */
-inline bool lfnLegalChar(uint8_t c) {
-#if USE_UTF8_LONG_NAMES
-  return !lfnReservedChar(c);
-#else  // USE_UTF8_LONG_NAMES
-  return !(lfnReservedChar(c) || c & 0X80);
-#endif  // USE_UTF8_LONG_NAMES
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::attrib(uint8_t bits) {
-  if (!isFileOrSubDir() || (bits & FS_ATTRIB_USER_SETTABLE) != bits) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Don't allow read-only to be set if the file is open for write.
-  if ((bits & FS_ATTRIB_READ_ONLY) && isWritable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_attributes = (m_attributes & ~FS_ATTRIB_USER_SETTABLE) | bits;
-  // insure sync() will update dir entry
-  m_flags |= FILE_FLAG_DIR_DIRTY;
-  if (!sync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-uint8_t* ExFatFile::dirCache(uint8_t set, uint8_t options) {
-  DirPos_t pos = m_dirPos;
-  if (m_vol->dirSeek(&pos, FS_DIR_SIZE*set) != 1) {
-    return nullptr;
-  }
-  return m_vol->dirCache(&pos, options);
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::close() {
-  bool rtn = sync();
-  m_attributes = FILE_ATTR_CLOSED;
-  m_flags = 0;
-  return rtn;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::contiguousRange(uint32_t* bgnSector, uint32_t* endSector) {
-  if (!isContiguous()) {
-    return false;
-  }
-  if (bgnSector) {
-    *bgnSector = firstSector();
-  }
-  if (endSector) {
-    *endSector = firstSector() +
-                 ((m_validLength - 1) >> m_vol->bytesPerSectorShift());
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-void ExFatFile::fgetpos(fspos_t* pos) const {
-  pos->position = m_curPosition;
-  pos->cluster = m_curCluster;
-}
-//------------------------------------------------------------------------------
-int ExFatFile::fgets(char* str, int num, char* delim) {
-  char ch;
-  int n = 0;
-  int r = -1;
-  while ((n + 1) < num && (r = read(&ch, 1)) == 1) {
-    // delete CR
-    if (ch == '\r') {
-      continue;
-    }
-    str[n++] = ch;
-    if (!delim) {
-      if (ch == '\n') {
-        break;
-      }
-    } else {
-      if (strchr(delim, ch)) {
-        break;
-      }
-    }
-  }
-  if (r < 0) {
-    // read error
-    return -1;
-  }
-  str[n] = '\0';
-  return n;
-}
-//------------------------------------------------------------------------------
-uint32_t ExFatFile::firstSector() const {
-  return m_firstCluster ? m_vol->clusterStartSector(m_firstCluster) : 0;
-}
-//------------------------------------------------------------------------------
-void ExFatFile::fsetpos(const fspos_t* pos) {
-  m_curPosition = pos->position;
-  m_curCluster = pos->cluster;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::getAccessDateTime(uint16_t* pdate, uint16_t* ptime) {
-  DirFile_t* df = reinterpret_cast<DirFile_t*>
-                 (m_vol->dirCache(&m_dirPos, FsCache::CACHE_FOR_READ));
-  if (!df) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  *pdate = getLe16(df->accessDate);
-  *ptime = getLe16(df->accessTime);
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::getCreateDateTime(uint16_t* pdate, uint16_t* ptime) {
-  DirFile_t* df = reinterpret_cast<DirFile_t*>
-                 (m_vol->dirCache(&m_dirPos, FsCache::CACHE_FOR_READ));
-  if (!df) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  *pdate = getLe16(df->createDate);
-  *ptime = getLe16(df->createTime);
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::getModifyDateTime(uint16_t* pdate, uint16_t* ptime) {
-  DirFile_t* df = reinterpret_cast<DirFile_t*>
-                 (m_vol->dirCache(&m_dirPos, FsCache::CACHE_FOR_READ));
-  if (!df) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  *pdate = getLe16(df->modifyDate);
-  *ptime = getLe16(df->modifyTime);
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::isBusy() {
-  return m_vol->isBusy();
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::open(const char* path, oflag_t oflag) {
-  return open(ExFatVolume::cwv(), path, oflag);
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::open(ExFatVolume* vol, const char* path, oflag_t oflag) {
-  return vol && open(vol->vwd(), path, oflag);
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::open(ExFatFile* dirFile, const char* path, oflag_t oflag) {
-  ExFatFile tmpDir;
-  ExName_t fname;
-  // error if already open
-  if (isOpen() || !dirFile->isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (isDirSeparator(*path)) {
-    while (isDirSeparator(*path)) {
-      path++;
-    }
-    if (*path == 0) {
-      return openRoot(dirFile->m_vol);
-    }
-    if (!tmpDir.openRoot(dirFile->m_vol)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    dirFile = &tmpDir;
-  }
-  while (1) {
-    if (!parsePathName(path, &fname, &path)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (*path == 0) {
-      break;
-    }
-    if (!openPrivate(dirFile, &fname, O_RDONLY)) {
-      DBG_WARN_MACRO;
-      goto fail;
-    }
-    tmpDir = *this;
-    dirFile = &tmpDir;
-    close();
-  }
-  return openPrivate(dirFile, &fname, oflag);
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::open(uint32_t index, oflag_t oflag) {
-  ExFatVolume* vol = ExFatVolume::cwv();
-  return vol ? open(vol->vwd(), index, oflag) : false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::open(ExFatFile* dirFile, uint32_t index, oflag_t oflag) {
-  if (dirFile->seekSet(FS_DIR_SIZE*index) && openNext(dirFile, oflag)) {
-    if (dirIndex() == index) {
-      return true;
-    }
-    close();
-    DBG_FAIL_MACRO;
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::openCwd() {
-  if (isOpen() || !ExFatVolume::cwv()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  *this = *ExFatVolume::cwv()->vwd();
-  rewind();
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::openNext(ExFatFile* dir, oflag_t oflag) {
-  if (isOpen() || !dir->isDir() || (dir->curPosition() & 0X1F)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return openPrivate(dir, nullptr, oflag);
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::openPrivate(ExFatFile* dir, ExName_t* fname, oflag_t oflag) {
-  int n;
-  uint8_t modeFlags;
-  uint32_t curCluster __attribute__((unused));
-  uint8_t* cache __attribute__((unused));
-  DirPos_t freePos __attribute__((unused));
-
-  DirFile_t*   dirFile;
-  DirStream_t* dirStream;
-  DirName_t*   dirName;
-  uint8_t buf[FS_DIR_SIZE];
-  uint8_t freeCount = 0;
-  uint8_t freeNeed = 3;
-  bool inSet = false;
-
-  // error if already open, no access mode, or no directory.
-  if (isOpen() || !dir->isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-
-  switch (oflag & O_ACCMODE) {
-    case O_RDONLY:
-      modeFlags = FILE_FLAG_READ;
-      break;
-    case O_WRONLY:
-      modeFlags = FILE_FLAG_WRITE;
-      break;
-    case O_RDWR:
-      modeFlags = FILE_FLAG_READ | FILE_FLAG_WRITE;
-      break;
-    default:
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-  modeFlags |= oflag & O_APPEND ? FILE_FLAG_APPEND : 0;
-
-  if (fname) {
-    freeNeed = 2 + (fname->nameLength + 14)/15;
-    dir->rewind();
-  }
-
-  while (1) {
-    n = dir->read(buf, FS_DIR_SIZE);
-    if (n == 0) {
-      goto create;
-    }
-    if (n != FS_DIR_SIZE) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (!(buf[0] & EXFAT_TYPE_USED)) {
-      // Unused entry.
-      if (freeCount == 0) {
-        freePos.position = dir->curPosition() - FS_DIR_SIZE;
-        freePos.cluster = dir->curCluster();
-      }
-      if (freeCount < freeNeed) {
-        freeCount++;
-      }
-      if (buf[0] == EXFAT_TYPE_END_DIR) {
-        if (fname) {
-          goto create;
-        }
-        // Likely openNext call.
-        DBG_WARN_MACRO;
-        goto fail;
-      }
-      inSet = false;
-    } else if (!inSet) {
-      if (freeCount < freeNeed) {
-        freeCount = 0;
-      }
-      if (buf[0] != EXFAT_TYPE_FILE) {
-        continue;
-      }
-      inSet = true;
-      memset(this, 0, sizeof(ExFatFile));
-      dirFile = reinterpret_cast<DirFile_t*>(buf);
-      m_setCount = dirFile->setCount;
-      m_attributes = getLe16(dirFile->attributes) & FS_ATTRIB_COPY;
-      if (!(m_attributes & FS_ATTRIB_DIRECTORY)) {
-        m_attributes |= FILE_ATTR_FILE;
-      }
-      m_vol = dir->volume();
-      m_dirPos.cluster = dir->curCluster();
-      m_dirPos.position = dir->curPosition() - FS_DIR_SIZE;
-      m_dirPos.isContiguous = dir->isContiguous();
-    } else if (buf[0] == EXFAT_TYPE_STREAM) {
-      dirStream = reinterpret_cast<DirStream_t*>(buf);
-      m_flags = modeFlags;
-      if (dirStream->flags & EXFAT_FLAG_CONTIGUOUS) {
-        m_flags |= FILE_FLAG_CONTIGUOUS;
-      }
-      m_validLength = getLe64(dirStream->validLength);
-      m_firstCluster = getLe32(dirStream->firstCluster);
-      m_dataLength = getLe64(dirStream->dataLength);
-      if (!fname) {
-        goto found;
-      }
-      fname->reset();
-      if (fname->nameLength != dirStream->nameLength ||
-          fname->nameHash != getLe16(dirStream->nameHash)) {
-        inSet = false;
-      }
-    } else if (buf[0] == EXFAT_TYPE_NAME) {
-      dirName = reinterpret_cast<DirName_t*>(buf);
-      if (!cmpName(dirName, fname)) {
-        inSet = false;
-        continue;
-      }
-      if (fname->atEnd()) {
-        goto found;
-      }
-    } else {
-      inSet = false;
-    }
-  }
-
- found:
-  // Don't open if create only.
-  if (oflag & O_EXCL) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Write, truncate, or at end is an error for a directory or read-only file.
-  if ((oflag & (O_TRUNC | O_AT_END)) || (m_flags & FILE_FLAG_WRITE)) {
-    if (isSubDir() || isReadOnly() || EXFAT_READ_ONLY) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-
-#if !EXFAT_READ_ONLY
-  if (oflag & O_TRUNC) {
-    if (!(m_flags & FILE_FLAG_WRITE)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (!truncate(0)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  } else if ((oflag & O_AT_END) && !seekSet(fileSize())) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (isWritable()) {
-    m_attributes |= FS_ATTRIB_ARCHIVE;
-  }
-#endif  // !EXFAT_READ_ONLY
-  return true;
-
- create:
-#if EXFAT_READ_ONLY
-  DBG_FAIL_MACRO;
-  goto fail;
-#else  // EXFAT_READ_ONLY
-  // don't create unless O_CREAT and write
-  if (!(oflag & O_CREAT) || !(modeFlags & FILE_FLAG_WRITE) || !fname) {
-    DBG_WARN_MACRO;
-    goto fail;
-  }
-  while (freeCount < freeNeed) {
-    n = dir->read(buf, FS_DIR_SIZE);
-    if (n == 0) {
-      curCluster = dir->m_curCluster;
-      if (!dir->addDirCluster()) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      dir->m_curCluster = curCluster;
-      continue;
-    }
-    if (n != FS_DIR_SIZE) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (freeCount == 0) {
-      freePos.position = dir->curPosition() - FS_DIR_SIZE;
-      freePos.cluster = dir->curCluster();
-    }
-    freeCount++;
-  }
-  freePos.isContiguous = dir->isContiguous();
-  memset(this, 0, sizeof(ExFatFile));
-  m_vol = dir->volume();
-  m_attributes = FILE_ATTR_FILE | FS_ATTRIB_ARCHIVE;
-  m_dirPos = freePos;
-  fname->reset();
-  for (uint8_t i = 0; i < freeNeed; i++) {
-    cache = dirCache(i, FsCache::CACHE_FOR_WRITE);
-    if (!cache || (cache[0] & 0x80)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    memset(cache, 0 , FS_DIR_SIZE);
-    if (i == 0) {
-      dirFile = reinterpret_cast<DirFile_t*>(cache);
-      dirFile->type = EXFAT_TYPE_FILE;
-      m_setCount = freeNeed - 1;
-      dirFile->setCount = m_setCount;
-
-      if (FsDateTime::callback) {
-        uint16_t date, time;
-        uint8_t ms10;
-        FsDateTime::callback(&date, &time, &ms10);
-        setLe16(dirFile->createDate, date);
-        setLe16(dirFile->createTime, time);
-        dirFile->createTimeMs = ms10;
-      } else {
-        setLe16(dirFile->createDate, FS_DEFAULT_DATE);
-        setLe16(dirFile->modifyDate, FS_DEFAULT_DATE);
-        setLe16(dirFile->accessDate, FS_DEFAULT_DATE);
-       if (FS_DEFAULT_TIME) {
-         setLe16(dirFile->createTime, FS_DEFAULT_TIME);
-         setLe16(dirFile->modifyTime, FS_DEFAULT_TIME);
-         setLe16(dirFile->accessTime, FS_DEFAULT_TIME);
-       }
-      }
-    } else if (i == 1) {
-      dirStream = reinterpret_cast<DirStream_t*>(cache);
-      dirStream->type = EXFAT_TYPE_STREAM;
-      dirStream->flags = EXFAT_FLAG_ALWAYS1;
-      m_flags = modeFlags | FILE_FLAG_DIR_DIRTY;
-      dirStream->nameLength = fname->nameLength;
-      setLe16(dirStream->nameHash, fname->nameHash);
-    } else {
-      dirName = reinterpret_cast<DirName_t*>(cache);
-      dirName->type = EXFAT_TYPE_NAME;
-      for (size_t k = 0; k < 15; k++) {
-        if (fname->atEnd()) {
-          break;
-        }
-        uint16_t u = fname->get16();
-        setLe16(dirName->unicode + 2*k, u);
-      }
-    }
-  }
-  return sync();
-#endif  // EXFAT_READ_ONLY
-
- fail:
-  // close file
-  m_attributes = FILE_ATTR_CLOSED;
-  m_flags = 0;
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::openRoot(ExFatVolume* vol) {
-  if (isOpen()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  memset(this, 0, sizeof(ExFatFile));
-  m_attributes = FILE_ATTR_ROOT;
-  m_vol = vol;
-  m_flags = FILE_FLAG_READ;
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::parsePathName(const char* path,
-                            ExName_t* fname, const char** ptr) {
-  // Skip leading spaces.
-  while (*path == ' ') {
-    path++;
-  }
-  fname->begin = path;
-  fname->end = path;
-  while (*path && !isDirSeparator(*path)) {
-    uint8_t c = *path++;
-    if (!lfnLegalChar(c)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (c != '.' && c != ' ') {
-      // Need to trim trailing dots spaces.
-      fname->end = path;
-    }
-  }
-  // Advance to next path component.
-  for (; *path == ' ' || isDirSeparator(*path); path++) {}
-  *ptr = path;
-  return hashName(fname);
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-int ExFatFile::peek() {
-  uint64_t curPosition = m_curPosition;
-  uint32_t curCluster = m_curCluster;
-  int c = read();
-  m_curPosition = curPosition;
-  m_curCluster = curCluster;
-  return c;
-}
-//------------------------------------------------------------------------------
-int ExFatFile::read(void* buf, size_t count) {
-  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
-  int8_t fg;
-  size_t toRead = count;
-  size_t n;
-  uint8_t* cache;
-  uint16_t sectorOffset;
-  uint32_t sector;
-  uint32_t clusterOffset;
-
-  if (!isReadable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (isContiguous() || isFile()) {
-    if ((m_curPosition + count) > m_validLength) {
-      count = toRead = m_validLength - m_curPosition;
-    }
-  }
-  while (toRead) {
-    clusterOffset = m_curPosition & m_vol->clusterMask();
-    sectorOffset = clusterOffset & m_vol->sectorMask();
-    if (clusterOffset == 0) {
-      if (m_curPosition == 0) {
-        m_curCluster = isRoot()
-                       ? m_vol->rootDirectoryCluster() : m_firstCluster;
-      } else if (isContiguous()) {
-        m_curCluster++;
-      } else {
-        fg = m_vol->fatGet(m_curCluster, &m_curCluster);
-        if (fg < 0) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        if (fg == 0) {
-          // EOF if directory.
-          if (isDir()) {
-            break;
-          }
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-      }
-    }
-    sector = m_vol->clusterStartSector(m_curCluster) +
-             (clusterOffset >> m_vol->bytesPerSectorShift());
-    if (sectorOffset != 0 || toRead < m_vol->bytesPerSector()
-                          || sector == m_vol->dataCacheSector()) {
-      n = m_vol->bytesPerSector() - sectorOffset;
-      if (n > toRead) {
-        n = toRead;
-      }
-      // read sector to cache and copy data to caller
-      cache = m_vol->dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
-      if (!cache) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      uint8_t* src = cache + sectorOffset;
-      memcpy(dst, src, n);
-#if USE_MULTI_SECTOR_IO
-    } else if (toRead >= 2*m_vol->bytesPerSector()) {
-      uint32_t ns = toRead >> m_vol->bytesPerSectorShift();
-      // Limit reads to current cluster.
-      uint32_t maxNs = m_vol->sectorsPerCluster()
-                       - (clusterOffset >> m_vol->bytesPerSectorShift());
-      if (ns > maxNs) {
-        ns = maxNs;
-      }
-      n = ns << m_vol->bytesPerSectorShift();
-     if (!m_vol->cacheSafeRead(sector, dst, ns)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-#endif  // USE_MULTI_SECTOR_IO
-    } else {
-      // read single sector
-      n = m_vol->bytesPerSector();
-      if (!m_vol->cacheSafeRead(sector, dst)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    dst += n;
-    m_curPosition += n;
-    toRead -= n;
-  }
-  return count - toRead;
-
- fail:
-  m_error |= READ_ERROR;
-  return -1;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::remove(const char* path) {
-  ExFatFile file;
-  if (!file.open(this, path, O_WRONLY)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return file.remove();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::seekSet(uint64_t pos) {
-  uint32_t nCur;
-  uint32_t nNew;
-  uint32_t tmp = m_curCluster;
-  // error if file not open
-  if (!isOpen()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Optimize O_APPEND writes.
-  if (pos == m_curPosition) {
-    return true;
-  }
-  if (pos == 0) {
-    // set position to start of file
-    m_curCluster = 0;
-    goto done;
-  }
-  if (isFile()) {
-    if (pos > m_validLength) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  // calculate cluster index for new position
-  nNew = (pos - 1) >> m_vol->bytesPerClusterShift();
-  if (isContiguous()) {
-    m_curCluster = m_firstCluster + nNew;
-    goto done;
-  }
-  // calculate cluster index for current position
-  nCur = (m_curPosition - 1) >> m_vol->bytesPerClusterShift();
-  if (nNew < nCur || m_curPosition == 0) {
-    // must follow chain from first cluster
-    m_curCluster = isRoot() ? m_vol->rootDirectoryCluster() : m_firstCluster;
-  } else {
-    // advance from curPosition
-    nNew -= nCur;
-  }
-  while (nNew--) {
-    if (m_vol->fatGet(m_curCluster, &m_curCluster) <= 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-
- done:
-  m_curPosition = pos;
-  return true;
-
- fail:
-  m_curCluster = tmp;
-  return false;
-}

lib/SdFat_NoArduino/src/ExFatLib/ExFatFile.h

@@ -1,864 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef ExFatFile_h
-#define ExFatFile_h
-/**
- * \file
- * \brief ExFatFile class
- */
-#include <limits.h>
-#include <string.h>
-#include "../common/FsDateTime.h"
-#include "../common/FsApiConstants.h"
-#include "../common/FmtNumber.h"
-#include "../common/FsName.h"
-#include "ExFatPartition.h"
-
-class ExFatVolume;
-//------------------------------------------------------------------------------
-/** Expression for path name separator. */
-#define isDirSeparator(c) ((c) == '/')
-//------------------------------------------------------------------------------
-/**
- * \class ExName_t
- * \brief Internal type for file name - do not use in user apps.
- */
-class ExName_t : public FsName {
- public:
-  /** Length of UTF-16 name */
-  size_t nameLength;
-  /** Hash for UTF-16 name */
-  uint16_t nameHash;
-};
-//------------------------------------------------------------------------------
-/**
- * \class ExFatFile
- * \brief Basic file class.
- */
-class ExFatFile {
- public:
-  /** Create an instance. */
-  ExFatFile() {}
-  /**  Create a file object and open it in the current working directory.
-   *
-   * \param[in] path A path for a file to be opened.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
-   * OR of open flags. see FatFile::open(FatFile*, const char*, uint8_t).
-   */
-  ExFatFile(const char* path, oflag_t oflag) {
-    open(path, oflag);
-  }
-
-#if DESTRUCTOR_CLOSES_FILE
-  ~ExFatFile() {
-    if (isOpen()) {
-      close();
-    }
-  }
-#endif  // DESTRUCTOR_CLOSES_FILE
-
-  /** The parenthesis operator.
-    *
-    * \return true if a file is open.
-    */
-  operator bool() {
-    return isOpen();
-  }
-  /**
-   * \return user settable file attributes for success else -1.
-   */
-  int attrib() {
-    return isFileOrSubDir() ? m_attributes & FS_ATTRIB_COPY : -1;
-  }
-  /** Set file attributes
-   *
-   * \param[in] bits bit-wise or of selected attributes: FS_ATTRIB_READ_ONLY,
-   *            FS_ATTRIB_HIDDEN, FS_ATTRIB_SYSTEM, FS_ATTRIB_ARCHIVE.
-   *
-   * \note attrib() will fail for set read-only if the file is open for write.
-   * \return true for success or false for failure.
-   */
-  bool attrib(uint8_t bits);
-  /** \return The number of bytes available from the current position
-   * to EOF for normal files.  INT_MAX is returned for very large files.
-   *
-   * available64() is recommended for very large files.
-   *
-   * Zero is returned for directory files.
-   *
-   */
-  int available() {
-    uint64_t n = available64();
-    return n > INT_MAX ? INT_MAX : n;
-  }
-  /** \return The number of bytes available from the current position
-   * to EOF for normal files.  Zero is returned for directory files.
-   */
-  uint64_t available64() {
-    return isFile() ? fileSize() - curPosition() : 0;
-  }
-  /** Clear all error bits. */
-  void clearError() {
-    m_error = 0;
-  }
-  /** Clear writeError. */
-  void clearWriteError() {
-    m_error &= ~WRITE_ERROR;
-  }
-  /** Close a file and force cached data and directory information
-   *  to be written to the storage device.
-   *
-   * \return true for success or false for failure.
-   */
-  bool close();
-  /** Check for contiguous file and return its raw sector range.
-   *
-   * \param[out] bgnSector the first sector address for the file.
-   * \param[out] endSector the last sector address for the file.
-   *
-   * Parameters may be nullptr.
-   *
-   * \return true for success or false for failure.
-   */
-  bool contiguousRange(uint32_t* bgnSector, uint32_t* endSector);
-  /** \return The current cluster number for a file or directory. */
-  uint32_t curCluster() const {return m_curCluster;}
-  /** \return The current position for a file or directory. */
-  uint64_t curPosition() const {return m_curPosition;}
-  /** \return Total data length for file. */
-  uint64_t dataLength() const {return m_dataLength;}
-  /** \return Directory entry index. */
-  uint32_t dirIndex() const {return m_dirPos.position/FS_DIR_SIZE;}
-  /** Test for the existence of a file in a directory
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * The calling instance must be an open directory file.
-   *
-   * dirFile.exists("TOFIND.TXT") searches for "TOFIND.TXT" in the directory
-   * dirFile.
-   *
-   * \return true if the file exists else false.
-   */
-    bool exists(const char* path) {
-      ExFatFile file;
-      return file.open(this, path, O_RDONLY);
-    }
-  /** get position for streams
-   * \param[out] pos struct to receive position
-   */
-  void fgetpos(fspos_t* pos) const;
- /**
-   * Get a string from a file.
-   *
-   * fgets() reads bytes from a file into the array pointed to by \a str, until
-   * \a num - 1 bytes are read, or a delimiter is read and transferred to
-   * \a str, or end-of-file is encountered. The string is then terminated
-   * with a null byte.
-   *
-   * fgets() deletes CR, '\\r', from the string.  This insures only a '\\n'
-   * terminates the string for Windows text files which use CRLF for newline.
-   *
-   * \param[out] str Pointer to the array where the string is stored.
-   * \param[in] num Maximum number of characters to be read
-   * (including the final null byte). Usually the length
-   * of the array \a str is used.
-   * \param[in] delim Optional set of delimiters. The default is "\n".
-   *
-   * \return For success fgets() returns the length of the string in \a str.
-   * If no data is read, fgets() returns zero for EOF or -1 if an error
-   * occurred.
-   */
-  int fgets(char* str, int num, char* delim = nullptr);
-  /** \return The total number of bytes in a file. */
-  uint64_t fileSize() const {return m_validLength;}
-  /** \return Address of first sector or zero for empty file. */
-  uint32_t firstSector() const;
-  /** Set position for streams
-   * \param[in] pos struct with value for new position
-   */
-  void fsetpos(const fspos_t* pos);
-  /** Arduino name for sync() */
-  void flush() {sync();}
-  /** Get a file's access date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime Packed time for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getAccessDateTime(uint16_t* pdate, uint16_t* ptime);
-  /** Get a file's create date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime Packed time for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getCreateDateTime(uint16_t* pdate, uint16_t* ptime);
-  /** \return All error bits. */
-  uint8_t getError() const {
-    return isOpen() ? m_error : 0XFF;
-  }
-  /** Get a file's modify date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime Packed time for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getModifyDateTime(uint16_t* pdate, uint16_t* ptime);
-  /**
-   * Get a file's name followed by a zero.
-   *
-   * \param[out] name An array of characters for the file's name.
-   * \param[in] size The size of the array in characters.
-   * \return the name length.
-   */
-  size_t getName(char* name, size_t size) {
-#if USE_UTF8_LONG_NAMES
-    return getName8(name, size);
-#else  // USE_UTF8_LONG_NAMES
-    return getName7(name, size);
-#endif  // USE_UTF8_LONG_NAMES
-  }
-  /**
-   * Get a file's ASCII name followed by a zero.
-   *
-   * \param[out] name An array of characters for the file's name.
-   * \param[in] size The size of the array in characters.
-   * \return the name length.
-   */
-  size_t getName7(char* name, size_t size);
-  /**
-   * Get a file's UTF-8 name followed by a zero.
-   *
-   * \param[out] name An array of characters for the file's name.
-   * \param[in] size The size of the array in characters.
-   * \return the name length.
-   */
-  size_t getName8(char* name, size_t size);
-  /** \return value of writeError */
-  bool getWriteError() const {
-    return isOpen() ? m_error & WRITE_ERROR : true;
-  }
-  /**
-   * Check for FsBlockDevice busy.
-   *
-   * \return true if busy else false.
-   */
-  bool isBusy();
-  /** \return True if the file is contiguous. */
-  bool isContiguous() const {return m_flags & FILE_FLAG_CONTIGUOUS;}
-  /** \return True if this is a directory. */
-  bool isDir() const  {return m_attributes & FILE_ATTR_DIR;}
-  /** \return True if this is a normal file. */
-  bool isFile() const {return m_attributes & FILE_ATTR_FILE;}
-  /** \return True if this is a normal file or sub-directory. */
-  bool isFileOrSubDir() const {return isFile() || isSubDir();}
-  /** \return True if this is a hidden. */
-  bool isHidden() const {return m_attributes & FS_ATTRIB_HIDDEN;}
-  /** \return true if the file is open. */
-  bool isOpen() const {return m_attributes;}
-  /** \return True if file is read-only */
-  bool isReadOnly() const {return m_attributes & FS_ATTRIB_READ_ONLY;}
-  /** \return True if this is the root directory. */
-  bool isRoot() const {return m_attributes & FILE_ATTR_ROOT;}
-  /** \return True file is readable. */
-  bool isReadable() const {return m_flags & FILE_FLAG_READ;}
-  /** \return True if this is a sub-directory. */
-  bool isSubDir() const {return m_attributes & FILE_ATTR_SUBDIR;}
-  /** \return True if this is a system file. */
-  bool isSystem() const {return m_attributes & FS_ATTRIB_SYSTEM;}
-  /** \return True file is writable. */
-  bool isWritable() const {return m_flags & FILE_FLAG_WRITE;}
-  /** List directory contents.
-   *
-   * \param[in] pr Print stream for list.
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr);
-  /** List directory contents.
-   *
-   * \param[in] pr Print stream for list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of sub-directories.
-   *
-   * \param[in] indent Amount of space before file name. Used for recursive
-   * list to indicate sub-directory level.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, uint8_t flags, uint8_t indent = 0);
-  /** Make a new directory.
-   *
-   * \param[in] parent An open directory file that will
-   *                   contain the new directory.
-   *
-   * \param[in] path A path with a valid name for the new directory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(ExFatFile* parent, const char* path, bool pFlag = true);
-  /** Open a file or directory by name.
-   *
-   * \param[in] dirFile An open directory containing the file to be opened.
-   *
-   * \param[in] path The path for a file to be opened.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a
-   *                  bitwise-inclusive OR of flags from the following list.
-   *                  Only one of O_RDONLY, O_READ, O_WRONLY, O_WRITE, or
-   *                  O_RDWR is allowed.
-   *
-   * O_RDONLY - Open for reading.
-   *
-   * O_READ - Same as O_RDONLY.
-   *
-   * O_WRONLY - Open for writing.
-   *
-   * O_WRITE - Same as O_WRONLY.
-   *
-   * O_RDWR - Open for reading and writing.
-   *
-   * O_APPEND - If set, the file offset shall be set to the end of the
-   * file prior to each write.
-   *
-   * O_AT_END - Set the initial position at the end of the file.
-   *
-   * O_CREAT - If the file exists, this flag has no effect except as noted
-   * under O_EXCL below. Otherwise, the file shall be created
-   *
-   * O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file
-   * exists.
-   *
-   * O_TRUNC - If the file exists and is a regular file, and the file is
-   * successfully opened and is not read only, its length shall be truncated
-   * to 0.
-   *
-   * WARNING: A given file must not be opened by more than one file object
-   * or file corruption may occur.
-   *
-   * \note Directory files must be opened read only.  Write and truncation is
-   * not allowed for directory files.
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(ExFatFile* dirFile, const char* path, oflag_t oflag = O_RDONLY);
-  /** Open a file in the volume working directory.
-   *
-   * \param[in] vol Volume where the file is located.
-   *
-   * \param[in] path with a valid name for a file to be opened.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see open(ExFatFile*, const char*, uint8_t).
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(ExFatVolume* vol, const char* path, oflag_t oflag = O_RDONLY);
-  /** Open a file by index.
-   *
-   * \param[in] dirFile An open ExFatFile instance for the directory.
-   *
-   * \param[in] index The \a index of the directory entry for the file to be
-   * opened.  The value for \a index is (directory file position)/32.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *            See see ExFatFile::open(ExFatFile*, const char*, uint8_t).
-   *
-   * See open() by path for definition of flags.
-   * \return true for success or false for failure.
-   */
-  bool open(ExFatFile* dirFile, uint32_t index, oflag_t oflag = O_RDONLY);
-  /** Open a file by index in the current working directory.
-   *
-   * \param[in] index The \a index of the directory entry for the file to be
-   * opened.  The value for \a index is (directory file position)/32.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see FatFile::open(FatFile*, const char*, uint8_t).
-   *
-   * See open() by path for definition of flags.
-   * \return true for success or false for failure.
-   */
-  bool open(uint32_t index, oflag_t oflag = O_RDONLY);
-  /** Open a file in the current working directory.
-   *
-   * \param[in] path A path with a valid name for a file to be opened.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see ExFatFile::open(ExFatFile*, const char*, uint8_t).
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(const char* path, oflag_t oflag = O_RDONLY);
-   /** Open the current working directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool openCwd();
-  /** Open the next file or subdirectory in a directory.
-   *
-   * \param[in] dirFile An open instance for the directory
-   *                    containing the file to be opened.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see open(ExFatFile*, const char*, uint8_t).
-   *
-   * \return true for success or false for failure.
-   */
-  bool openNext(ExFatFile* dirFile, oflag_t oflag = O_RDONLY);
-  /** Open a volume's root directory.
-   *
-   * \param[in] vol The FAT volume containing the root directory to be opened.
-   *
-   * \return true for success or false for failure.
-   */
-  bool openRoot(ExFatVolume* vol);
-  /** Return the next available byte without consuming it.
-   *
-   * \return The byte if no error and not at eof else -1;
-   */
-  int peek();
-  /** Allocate contiguous clusters to an empty file.
-   *
-   * The file must be empty with no clusters allocated.
-   *
-   * The file will have zero validLength and dataLength
-   * will equal the requested length.
-   *
-   * \param[in] length size of allocated space in bytes.
-   * \return true for success or false for failure.
-   */
-  bool preAllocate(uint64_t length);
-     /** Print a file's access date and time
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printAccessDateTime(print_t* pr);
-   /** Print a file's creation date and time
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printCreateDateTime(print_t* pr);
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  size_t printField(double value, char term, uint8_t prec = 2) {
-    char buf[24];
-    char* str = buf + sizeof(buf);
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    str = fmtDouble(str, value, prec, false);
-    return write(str, buf + sizeof(buf) - str);
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  size_t printField(float value, char term, uint8_t prec = 2) {
-    return printField(static_cast<double>(value), term, prec);
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  template <typename Type>
-  size_t printField(Type value, char term) {
-    char sign = 0;
-    char buf[3*sizeof(Type) + 3];
-    char* str = buf + sizeof(buf);
-
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    if (value < 0) {
-      value = -value;
-      sign = '-';
-    }
-    if (sizeof(Type) < 4) {
-      str = fmtBase10(str, (uint16_t)value);
-    } else {
-      str = fmtBase10(str, (uint32_t)value);
-    }
-    if (sign) {
-      *--str = sign;
-    }
-    return write(str, &buf[sizeof(buf)] - str);
-  }
-  /** Print a file's size in bytes.
-   * \param[in] pr Prtin stream for the output.
-   * \return The number of bytes printed.
-   */
-  size_t printFileSize(print_t* pr);
-  /** Print a file's modify date and time
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printModifyDateTime(print_t* pr);
-  /** Print a file's name
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return length for success or zero for failure.
-   */
-  size_t printName(print_t* pr) {
-#if USE_UTF8_LONG_NAMES
-    return printName8(pr);
-#else  // USE_UTF8_LONG_NAMES
-    return printName7(pr);
-#endif  // USE_UTF8_LONG_NAMES
-  }
-  /** Print a file's ASCII name
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printName7(print_t* pr);
-  /** Print a file's UTF-8 name
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printName8(print_t* pr);
-  /** Read the next byte from a file.
-   *
-   * \return For success read returns the next byte in the file as an int.
-   * If an error occurs or end of file is reached -1 is returned.
-   */
-  int read() {
-    uint8_t b;
-    return read(&b, 1) == 1 ? b : -1;
-  }
-  /** Read data from a file starting at the current position.
-   *
-   * \param[out] buf Pointer to the location that will receive the data.
-   *
-   * \param[in] count Maximum number of bytes to read.
-   *
-   * \return For success read() returns the number of bytes read.
-   * A value less than \a nbyte, including zero, will be returned
-   * if end of file is reached.
-   * If an error occurs, read() returns -1.
-   */
-  int read(void* buf, size_t count);
-  /** Remove a file.
-   *
-   * The directory entry and all data for the file are deleted.
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * file that has a long name. For example if a file has the long name
-   * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove();
-  /** Remove a file.
-   *
-   * The directory entry and all data for the file are deleted.
-   *
-   * \param[in] path Path for the file to be removed.
-   *
-   * Example use: dirFile.remove(filenameToRemove);
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * file that has a long name. For example if a file has the long name
-   * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove(const char* path);
-   /** Rename a file or subdirectory.
-   *
-   * \param[in] newPath New path name for the file/directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const char* newPath);
-   /** Rename a file or subdirectory.
-   *
-   * \param[in] dirFile Directory for the new path.
-   * \param[in] newPath New path name for the file/directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(ExFatFile* dirFile, const char* newPath);
-  /** Set the file's current position to zero. */
-  void rewind() {
-    seekSet(0);
-  }
-  /** Remove a directory file.
-   *
-   * The directory file will be removed only if it is empty and is not the
-   * root directory.  rmdir() follows DOS and Windows and ignores the
-   * read-only attribute for the directory.
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * directory that has a long name. For example if a directory has the
-   * long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir();
-  /** Set the files position to current position + \a pos. See seekSet().
-   * \param[in] offset The new position in bytes from the current position.
-   * \return true for success or false for failure.
-   */
-  bool seekCur(int64_t offset) {
-    return seekSet(m_curPosition + offset);
-  }
-  /** Set the files position to end-of-file + \a offset. See seekSet().
-   * Can't be used for directory files since file size is not defined.
-   * \param[in] offset The new position in bytes from end-of-file.
-   * \return true for success or false for failure.
-   */
-  bool seekEnd(int64_t offset = 0) {
-    return isFile() ? seekSet(m_validLength + offset) : false;
-  }
-  /** Sets a file's position.
-   *
-   * \param[in] pos The new position in bytes from the beginning of the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool seekSet(uint64_t pos);
-  /** \return directory set count */
-  uint8_t setCount() const {return m_setCount;}
-  /** The sync() call causes all modified data and directory fields
-   * to be written to the storage device.
-   *
-   * \return true for success or false for failure.
-   */
-  bool sync();
-  /** Truncate a file at the current file position.
-   *
-   * \return true for success or false for failure.
-   */
-  /** Set a file's timestamps in its directory entry.
-   *
-   * \param[in] flags Values for \a flags are constructed by a
-   * bitwise-inclusive OR of flags from the following list
-   *
-   * T_ACCESS - Set the file's last access date and time.
-   *
-   * T_CREATE - Set the file's creation date and time.
-   *
-   * T_WRITE - Set the file's last write/modification date and time.
-   *
-   * \param[in] year Valid range 1980 - 2107 inclusive.
-   *
-   * \param[in] month Valid range 1 - 12 inclusive.
-   *
-   * \param[in] day Valid range 1 - 31 inclusive.
-   *
-   * \param[in] hour Valid range 0 - 23 inclusive.
-   *
-   * \param[in] minute Valid range 0 - 59 inclusive.
-   *
-   * \param[in] second Valid range 0 - 59 inclusive
-   *
-   * \note It is possible to set an invalid date since there is no check for
-   * the number of days in a month.
-   *
-   * \note
-   * Modify and access timestamps may be overwritten if a date time callback
-   * function has been set by dateTimeCallback().
-   *
-   * \return true for success or false for failure.
-   */
-  bool timestamp(uint8_t flags, uint16_t year, uint8_t month, uint8_t day,
-                 uint8_t hour, uint8_t minute, uint8_t second);
-  /** Truncate a file at the current file position.
-   * will be maintained if it is less than or equal to \a length otherwise
-   * it will be set to end of file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate();
-   /** Truncate a file to a specified length.  The current file position
-   * will be set to end of file.
-   *
-   * \param[in] length The desired length for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate(uint64_t length) {
-    return seekSet(length) && truncate();
-  }
-
-  /** \return The valid number of bytes in a file. */
-  uint64_t validLength() const {return m_validLength;}
-  /** Write a string to a file. Used by the Arduino Print class.
-   * \param[in] str Pointer to the string.
-   * Use getWriteError to check for errors.
-   * \return count of characters written for success or -1 for failure.
-   */
-  size_t write(const char* str) {
-    return write(str, strlen(str));
-  }
-  /** Write a single byte.
-   * \param[in] b The byte to be written.
-   * \return +1 for success or zero for failure.
-   */
-  size_t write(uint8_t b) {return write(&b, 1);}
-  /** Write data to an open file.
-   *
-   * \note Data is moved to the cache but may not be written to the
-   * storage device until sync() is called.
-   *
-   * \param[in] buf Pointer to the location of the data to be written.
-   *
-   * \param[in] count Number of bytes to write.
-   *
-   * \return For success write() returns the number of bytes written, always
-   * \a count. If an error occurs, write() returns zero and writeError is set.
-   */
-  size_t write(const void* buf, size_t count);
-//------------------------------------------------------------------------------
-#if ENABLE_ARDUINO_SERIAL
-  /** List directory contents.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(uint8_t flags = 0) {
-    return ls(&Serial, flags);
-  }
-  /** Print a file's name.
-   *
-   * \return length for success or zero for failure.
-   */
-  size_t printName() {
-    return ExFatFile::printName(&Serial);
-  }
-#endif  // ENABLE_ARDUINO_SERIAL
-
- private:
-  /** ExFatVolume allowed access to private members. */
-  friend class ExFatVolume;
-  bool addCluster();
-  bool addDirCluster();
-  bool cmpName(const DirName_t* dirName, ExName_t* fname);
-  uint8_t* dirCache(uint8_t set, uint8_t options);
-  bool hashName(ExName_t* fname);
-  bool mkdir(ExFatFile* parent, ExName_t* fname);
-
-  bool openPrivate(ExFatFile* dir, ExName_t* fname, oflag_t oflag);
-  bool parsePathName(const char* path,
-                            ExName_t* fname, const char** ptr);
-  ExFatVolume* volume() const {return m_vol;}
-  bool syncDir();
-  //----------------------------------------------------------------------------
-  static const uint8_t WRITE_ERROR = 0X1;
-  static const uint8_t READ_ERROR  = 0X2;
-
-  /** This file has not been opened. */
-  static const uint8_t FILE_ATTR_CLOSED = 0;
-  /** Entry for normal data file */
-  static const uint8_t FILE_ATTR_FILE = 0X08;
-  /** Entry is for a subdirectory */
-  static const uint8_t FILE_ATTR_SUBDIR = FS_ATTRIB_DIRECTORY;
-  /** Root directory */
-  static const uint8_t FILE_ATTR_ROOT = 0X40;
-  /** Directory type bits */
-  static const uint8_t FILE_ATTR_DIR = FILE_ATTR_SUBDIR | FILE_ATTR_ROOT;
-
-  static const uint8_t FILE_FLAG_READ = 0X01;
-  static const uint8_t FILE_FLAG_WRITE = 0X02;
-  static const uint8_t FILE_FLAG_APPEND = 0X08;
-  static const uint8_t FILE_FLAG_CONTIGUOUS  = 0X40;
-  static const uint8_t FILE_FLAG_DIR_DIRTY = 0X80;
-
-
-  uint64_t      m_curPosition;
-  uint64_t      m_dataLength;
-  uint64_t      m_validLength;
-  uint32_t      m_curCluster;
-  uint32_t      m_firstCluster;
-  ExFatVolume*  m_vol;
-  DirPos_t      m_dirPos;
-  uint8_t       m_setCount;
-  uint8_t       m_attributes = FILE_ATTR_CLOSED;
-  uint8_t       m_error = 0;
-  uint8_t       m_flags = 0;
-};
-
-#include "../common/ArduinoFiles.h"
-/**
- * \class ExFile
- * \brief exFAT file with Arduino Stream.
- */
-class ExFile : public StreamFile<ExFatFile, uint64_t> {
- public:
-   /** Opens the next file or folder in a directory.
-   *
-   * \param[in] oflag open flags.
-   * \return a FatStream object.
-   */
-  ExFile openNextFile(oflag_t oflag = O_RDONLY) {
-    ExFile tmpFile;
-    tmpFile.openNext(this, oflag);
-    return tmpFile;
-  }
-};
-#endif  // ExFatFile_h

lib/SdFat_NoArduino/src/ExFatLib/ExFatFilePrint.cpp

@@ -1,228 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "ExFatFilePrint.cpp"
-#include "../common/DebugMacros.h"
-#include "ExFatLib.h"
-#include "../common/FsUtf.h"
-//------------------------------------------------------------------------------
-bool ExFatFile::ls(print_t* pr) {
-  ExFatFile file;
-  if (!isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  rewind();
-  while (file.openNext(this, O_RDONLY)) {
-    if (!file.isHidden()) {
-      file.printName(pr);
-      if (file.isDir()) {
-        pr->write('/');
-      }
-      pr->write('\r');
-      pr->write('\n');
-    }
-    file.close();
-  }
-  if (getError()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::ls(print_t* pr, uint8_t flags, uint8_t indent) {
-  ExFatFile file;
-  if (!isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  rewind();
-  while (file.openNext(this, O_RDONLY)) {
-    // indent for dir level
-    if (!file.isHidden() || (flags & LS_A)) {
-      for (uint8_t i = 0; i < indent; i++) {
-        pr->write(' ');
-      }
-      if (flags & LS_DATE) {
-        file.printModifyDateTime(pr);
-        pr->write(' ');
-      }
-      if (flags & LS_SIZE) {
-        file.printFileSize(pr);
-        pr->write(' ');
-      }
-      file.printName(pr);
-      if (file.isDir()) {
-        pr->write('/');
-      }
-      pr->write('\r');
-      pr->write('\n');
-      if ((flags & LS_R) && file.isDir()) {
-        file.ls(pr, flags, indent + 2);
-      }
-    }
-    file.close();
-  }
-  if (getError()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::printAccessDateTime(print_t* pr) {
-  uint16_t date;
-  uint16_t time;
-  if (getAccessDateTime(&date, &time)) {
-    return fsPrintDateTime(pr, date, time);
-  }
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::printCreateDateTime(print_t* pr) {
-  uint16_t date;
-  uint16_t time;
-  if (getCreateDateTime(&date, &time)) {
-    return fsPrintDateTime(pr, date, time);
-  }
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::printFileSize(print_t* pr) {
-  uint64_t n = m_validLength;
-  char buf[21];
-  char *str = &buf[sizeof(buf) - 1];
-  char *bgn = str - 12;
-  *str = '\0';
-  do {
-    uint64_t m = n;
-    n /= 10;
-    *--str = m - 10*n + '0';
-  } while (n);
-  while (str > bgn) {
-    *--str = ' ';
-  }
-  return pr->write(str);
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::printModifyDateTime(print_t* pr) {
-  uint16_t date;
-  uint16_t time;
-  if (getModifyDateTime(&date, &time)) {
-    return fsPrintDateTime(pr, date, time);
-  }
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::printName7(print_t* pr) {
-  DirName_t* dn;
-  size_t n = 0;
-  uint8_t in;
-  uint8_t buf[15];
-  if (!isOpen()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-  for (uint8_t is = 2; is <= m_setCount; is++) {
-    dn = reinterpret_cast<DirName_t*>
-         (dirCache(is, FsCache::CACHE_FOR_READ));
-    if (!dn || dn->type != EXFAT_TYPE_NAME) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (in = 0; in < 15; in++) {
-      uint16_t c = getLe16(dn->unicode + 2*in);
-      if (!c) {
-        break;
-      }
-      buf[in] = c < 0X7F ? c : '?';
-      n++;
-    }
-    pr->write(buf, in);
-  }
-  return n;
-
- fail:
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::printName8(print_t *pr) {
-  DirName_t* dn;
-  uint16_t hs = 0;
-  uint32_t cp;
-  size_t n = 0;
-  uint8_t in;
-  char buf[5];
-  if (!isOpen()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-  for (uint8_t is = 2; is <= m_setCount; is++) {
-    dn = reinterpret_cast<DirName_t*>
-         (dirCache(is, FsCache::CACHE_FOR_READ));
-    if (!dn || dn->type != EXFAT_TYPE_NAME) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (in = 0; in < 15; in++) {
-      uint16_t c = getLe16(dn->unicode + 2*in);
-      if (hs) {
-        if (!FsUtf::isLowSurrogate(c)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        cp = FsUtf::u16ToCp(hs, c);
-        hs = 0;
-      } else if (!FsUtf::isSurrogate(c)) {
-        if (c == 0) {
-          break;
-        }
-        cp = c;
-      } else if (FsUtf::isHighSurrogate(c)) {
-        hs = c;
-        continue;
-      } else {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      char* str = FsUtf::cpToMb(cp, buf, buf + sizeof(buf));
-      if (!str) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      n += pr->write(buf, str - buf);
-    }
-  }
-  return n;
-
- fail:
-  return 0;
-}

lib/SdFat_NoArduino/src/ExFatLib/ExFatFileWrite.cpp

@@ -1,756 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "ExFatFileWrite.cpp"
-#include "../common/DebugMacros.h"
-#include "ExFatLib.h"
-//==============================================================================
-#if EXFAT_READ_ONLY
-bool ExFatFile::mkdir(ExFatFile* parent, const char* path, bool pFlag) {
-  (void) parent;
-  (void)path;
-  (void)pFlag;
-  return false;
-}
-bool ExFatFile::preAllocate(uint64_t length) {
-  (void)length;
-  return false;
-}
-bool ExFatFile::rename(const char* newPath) {
-  (void)newPath;
-  return false;
-}
-bool ExFatFile::rename(ExFatFile* dirFile, const char* newPath) {
-  (void)dirFile;
-  (void)newPath;
-  return false;
-}
-bool ExFatFile::sync() {
-  return false;
-}
-bool ExFatFile::truncate() {
-  return false;
-}
-size_t ExFatFile::write(const void* buf, size_t nbyte) {
-  (void)buf;
-  (void)nbyte;
-  return false;
-}
-//==============================================================================
-#else  // EXFAT_READ_ONLY
-//------------------------------------------------------------------------------
-static uint16_t exFatDirChecksum(const uint8_t* data, uint16_t checksum) {
-  bool skip = data[0] == EXFAT_TYPE_FILE;
-  for (size_t i = 0; i < 32; i += i == 1 && skip ? 3 : 1) {
-    checksum = ((checksum << 15) | (checksum >> 1)) + data[i];
-  }
-  return checksum;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::addCluster() {
-  uint32_t find = m_vol->bitmapFind(m_curCluster ?  m_curCluster + 1 : 0, 1);
-  if (find < 2) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!m_vol->bitmapModify(find, 1, 1)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (m_curCluster == 0) {
-    m_flags |= FILE_FLAG_CONTIGUOUS;
-    goto done;
-  }
-  if (isContiguous()) {
-    if (find == (m_curCluster + 1)) {
-      goto done;
-    }
-    // No longer contiguous so make FAT chain.
-    m_flags &= ~FILE_FLAG_CONTIGUOUS;
-
-    for (uint32_t c = m_firstCluster; c < m_curCluster; c++) {
-      if (!m_vol->fatPut(c, c + 1)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-  }
-  // New cluster is EOC.
-  if (!m_vol->fatPut(find, EXFAT_EOC)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Connect new cluster to existing chain.
-  if (m_curCluster) {
-    if (!m_vol->fatPut(m_curCluster, find)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-
- done:
-  m_curCluster = find;
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::addDirCluster() {
-  uint32_t sector;
-  uint32_t dl = isRoot() ? m_vol->rootLength() : m_dataLength;
-  uint8_t* cache;
-  dl += m_vol->bytesPerCluster();
-  if (dl >= 0X4000000) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!addCluster()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  sector = m_vol->clusterStartSector(m_curCluster);
-  for (uint32_t i = 0; i  < m_vol->sectorsPerCluster(); i++) {
-    cache = m_vol->dataCachePrepare(sector + i,
-                                    FsCache::CACHE_RESERVE_FOR_WRITE);
-    if (!cache) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    memset(cache, 0, m_vol->bytesPerSector());
-  }
-  if (!isRoot()) {
-    m_flags |= FILE_FLAG_DIR_DIRTY;
-    m_dataLength  += m_vol->bytesPerCluster();
-    m_validLength += m_vol->bytesPerCluster();
-  }
-  return sync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::mkdir(ExFatFile* parent, const char* path, bool pFlag) {
-  ExName_t fname;
-  ExFatFile tmpDir;
-
-  if (isOpen() || !parent->isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (isDirSeparator(*path)) {
-    while (isDirSeparator(*path)) {
-      path++;
-    }
-    if (!tmpDir.openRoot(parent->m_vol)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    parent = &tmpDir;
-  }
-  while (1) {
-    if (!parsePathName(path, &fname, &path)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (!*path) {
-      break;
-    }
-    if (!openPrivate(parent, &fname, O_RDONLY)) {
-      if (!pFlag || !mkdir(parent, &fname)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    tmpDir = *this;
-    parent = &tmpDir;
-    close();
-  }
-  return mkdir(parent, &fname);
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::mkdir(ExFatFile* parent, ExName_t* fname) {
-  if (!parent->isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // create a normal file
-  if (!openPrivate(parent, fname, O_CREAT | O_EXCL | O_RDWR)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // convert file to directory
-  m_attributes = FILE_ATTR_SUBDIR | FS_ATTRIB_ARCHIVE;
-
-  // allocate and zero first cluster
-  if (!addDirCluster()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_firstCluster = m_curCluster;
-
-  // Set to start of dir
-  rewind();
-  m_flags = FILE_FLAG_READ | FILE_FLAG_CONTIGUOUS | FILE_FLAG_DIR_DIRTY;
-  return sync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::preAllocate(uint64_t length) {
-  uint32_t find;
-  uint32_t need;
-  if (!length || !isWritable() || m_firstCluster) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  need = 1 + ((length - 1) >> m_vol->bytesPerClusterShift());
-  find = m_vol->bitmapFind(0, need);
-  if (find < 2) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!m_vol->bitmapModify(find, need, 1)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_dataLength = length;
-  m_firstCluster = find;
-  m_flags |= FILE_FLAG_DIR_DIRTY | FILE_FLAG_CONTIGUOUS;
-  if (!sync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::remove() {
-  uint8_t* cache;
-  if (!isWritable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Free any clusters.
-  if (m_firstCluster) {
-    if (isContiguous()) {
-      uint32_t nc = 1 + ((m_dataLength - 1) >> m_vol->bytesPerClusterShift());
-      if (!m_vol->bitmapModify(m_firstCluster, nc, 0)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    } else {
-      if (!m_vol->freeChain(m_firstCluster)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-  }
-
-  for (uint8_t is = 0; is <= m_setCount; is++) {
-    cache = dirCache(is, FsCache::CACHE_FOR_WRITE);
-    if (!cache) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // Mark entry not used.
-    cache[0] &= 0x7F;
-  }
-  // Set this file closed.
-  m_attributes = FILE_ATTR_CLOSED;
-  m_flags = 0;
-
-  // Write entry to device.
-  return m_vol->cacheSync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::rename(const char* newPath) {
-  return rename(m_vol->vwd(), newPath);
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::rename(ExFatFile* dirFile, const char* newPath) {
-  ExFatFile file;
-  ExFatFile oldFile;
-
-  // Must be an open file or subdirectory.
-  if (!(isFile() || isSubDir())) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Can't move file to new volume.
-  if (m_vol != dirFile->m_vol) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!file.open(dirFile, newPath, O_CREAT | O_EXCL | O_WRONLY)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  oldFile = *this;
-  m_dirPos = file.m_dirPos;
-  m_setCount = file.m_setCount;
-  m_flags |= FILE_FLAG_DIR_DIRTY;
-  if (!sync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Remove old directory entry;
-  oldFile.m_firstCluster = 0;
-  oldFile.m_flags = FILE_FLAG_WRITE;
-  oldFile.m_attributes = FILE_ATTR_FILE;
-  return oldFile.remove();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::rmdir() {
-  int n;
-  uint8_t dir[FS_DIR_SIZE];
-  // must be open subdirectory
-  if (!isSubDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  rewind();
-
-  // make sure directory is empty
-  while (1) {
-    n = read(dir, FS_DIR_SIZE);
-    if (n == 0) {
-      break;
-    }
-    if (n != FS_DIR_SIZE || dir[0] & 0X80) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (dir[0] == 0) {
-      break;
-    }
-  }
-  // convert empty directory to normal file for remove
-  m_attributes = FILE_ATTR_FILE;
-  m_flags |= FILE_FLAG_WRITE;
-  return remove();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::sync() {
-  if (!isOpen()) {
-    return true;
-  }
-  if (m_flags & FILE_FLAG_DIR_DIRTY) {
-    // clear directory dirty
-    m_flags &= ~FILE_FLAG_DIR_DIRTY;
-    return syncDir();
-  }
-  if (!m_vol->cacheSync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  m_error |= WRITE_ERROR;
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::syncDir() {
-  DirFile_t* df;
-  DirStream_t* ds;
-  uint8_t* cache;
-  uint16_t checksum = 0;
-
-  for (uint8_t is = 0; is <= m_setCount ; is++) {
-    cache = dirCache(is, FsCache::CACHE_FOR_READ);
-    if (!cache) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    switch (cache[0]) {
-      case EXFAT_TYPE_FILE:
-        df = reinterpret_cast<DirFile_t*>(cache);
-        setLe16(df->attributes, m_attributes & FS_ATTRIB_COPY);
-        if (FsDateTime::callback) {
-          uint16_t date, time;
-          uint8_t ms10;
-          FsDateTime::callback(&date, &time, &ms10);
-          df->modifyTimeMs = ms10;
-          setLe16(df->modifyTime, time);
-          setLe16(df->modifyDate, date);
-          setLe16(df->accessTime, time);
-          setLe16(df->accessDate, date);
-        }
-        m_vol->dataCacheDirty();
-        break;
-
-      case EXFAT_TYPE_STREAM:
-        ds = reinterpret_cast<DirStream_t*>(cache);
-        if (isContiguous()) {
-          ds->flags |= EXFAT_FLAG_CONTIGUOUS;
-        } else {
-          ds->flags &= ~EXFAT_FLAG_CONTIGUOUS;
-        }
-        setLe64(ds->validLength, m_validLength);
-        setLe32(ds->firstCluster, m_firstCluster);
-        setLe64(ds->dataLength, m_dataLength);
-        m_vol->dataCacheDirty();
-        break;
-
-      case EXFAT_TYPE_NAME:
-        break;
-
-      default:
-        DBG_FAIL_MACRO;
-        goto fail;
-        break;
-    }
-    checksum = exFatDirChecksum(cache, checksum);
-  }
-  df = reinterpret_cast<DirFile_t*>
-       (m_vol->dirCache(&m_dirPos, FsCache::CACHE_FOR_WRITE));
-  if (!df) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  setLe16(df->setChecksum, checksum);
-  if (!m_vol->cacheSync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  m_error |= WRITE_ERROR;
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
-                   uint8_t day, uint8_t hour, uint8_t minute, uint8_t second) {
-  DirFile_t* df;
-  uint8_t* cache;
-  uint16_t checksum = 0;
-  uint16_t date;
-  uint16_t time;
-  uint8_t ms10;
-
-  if (!isFile()
-      || year < 1980
-      || year > 2107
-      || month < 1
-      || month > 12
-      || day < 1
-      || day > 31
-      || hour > 23
-      || minute > 59
-      || second > 59) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // update directory entry
-  if (!sync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-
-  date = FS_DATE(year, month, day);
-  time = FS_TIME(hour, minute, second);
-  ms10 = second & 1 ? 100 : 0;
-
-  for (uint8_t is = 0; is <= m_setCount; is++) {
-    cache = dirCache(is, FsCache::CACHE_FOR_READ);
-    if (!cache) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    switch (cache[0]) {
-      case EXFAT_TYPE_FILE:
-        df = reinterpret_cast<DirFile_t*>(cache);
-        setLe16(df->attributes, m_attributes & FS_ATTRIB_COPY);
-        m_vol->dataCacheDirty();
-        if (flags & T_ACCESS) {
-          setLe16(df->accessTime, time);
-          setLe16(df->accessDate, date);
-        }
-        if (flags & T_CREATE) {
-          df->createTimeMs = ms10;
-          setLe16(df->createTime, time);
-          setLe16(df->createDate, date);
-        }
-        if (flags & T_WRITE) {
-          df->modifyTimeMs = ms10;
-          setLe16(df->modifyTime, time);
-          setLe16(df->modifyDate, date);
-        }
-        break;
-
-      case EXFAT_TYPE_STREAM:
-        break;
-
-      case EXFAT_TYPE_NAME:
-        break;
-
-      default:
-        DBG_FAIL_MACRO;
-        goto fail;
-        break;
-    }
-    checksum = exFatDirChecksum(cache, checksum);
-  }
-  df = reinterpret_cast<DirFile_t*>
-       (m_vol->dirCache(&m_dirPos, FsCache::CACHE_FOR_WRITE));
-  if (!df) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  setLe16(df->setChecksum, checksum);
-  if (!m_vol->cacheSync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::truncate() {
-  uint32_t toFree;
-  // error if not a normal file or read-only
-  if (!isWritable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (m_firstCluster == 0) {
-      return true;
-  }
-  if (isContiguous()) {
-    uint32_t nc = 1 + ((m_dataLength - 1) >> m_vol->bytesPerClusterShift());
-    if (m_curCluster) {
-      toFree = m_curCluster + 1;
-      nc -= 1 + m_curCluster - m_firstCluster;
-    } else {
-      toFree = m_firstCluster;
-      m_firstCluster = 0;
-    }
-    if (nc && !m_vol->bitmapModify(toFree, nc, 0)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  } else {
-    // need to free chain
-    if (m_curCluster) {
-      toFree = 0;
-      int8_t fg = m_vol->fatGet(m_curCluster, &toFree);
-      if (fg < 0) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      if (fg) {
-        // current cluster is end of chain
-        if (!m_vol->fatPut(m_curCluster, EXFAT_EOC)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-      }
-    } else {
-      toFree = m_firstCluster;
-      m_firstCluster = 0;
-    }
-    if (toFree) {
-      if (!m_vol->freeChain(toFree)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-  }
-  m_dataLength = m_curPosition;
-  m_validLength = m_curPosition;
-  m_flags |= FILE_FLAG_DIR_DIRTY;
-  return sync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::write(const void* buf, size_t nbyte) {
-  // convert void* to uint8_t*  -  must be before goto statements
-  const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);
-  uint8_t* cache;
-  uint8_t cacheOption;
-  uint16_t sectorOffset;
-  uint32_t sector;
-  uint32_t clusterOffset;
-
-  // number of bytes left to write  -  must be before goto statements
-  size_t toWrite = nbyte;
-  size_t n;
-  // error if not an open file or is read-only
-  if (!isWritable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // seek to end of file if append flag
-  if ((m_flags & FILE_FLAG_APPEND)) {
-    if (!seekSet(m_validLength)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  while (toWrite) {
-    clusterOffset = m_curPosition & m_vol->clusterMask();
-    sectorOffset = clusterOffset & m_vol->sectorMask();
-    if (clusterOffset == 0) {
-      // start of new cluster
-      if (m_curCluster != 0) {
-        int fg;
-
-        if (isContiguous()) {
-          uint32_t lc = m_firstCluster;
-          lc += (m_dataLength - 1) >> m_vol->bytesPerClusterShift();
-          if (m_curCluster < lc) {
-            m_curCluster++;
-            fg = 1;
-          } else {
-            fg = 0;
-          }
-        } else {
-          fg = m_vol->fatGet(m_curCluster, &m_curCluster);
-          if (fg < 0) {
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-        }
-        if (fg == 0) {
-          // add cluster if at end of chain
-          if (!addCluster()) {
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-        }
-      } else {
-        if (m_firstCluster == 0) {
-          // allocate first cluster of file
-          if (!addCluster()) {
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-          m_firstCluster = m_curCluster;
-        } else {
-          m_curCluster = m_firstCluster;
-        }
-      }
-    }
-    // sector for data write
-    sector = m_vol->clusterStartSector(m_curCluster) +
-             (clusterOffset >> m_vol->bytesPerSectorShift());
-
-    if (sectorOffset != 0 || toWrite < m_vol->bytesPerSector()) {
-      // partial sector - must use cache
-      // max space in sector
-      n = m_vol->bytesPerSector() - sectorOffset;
-      // lesser of space and amount to write
-      if (n > toWrite) {
-        n = toWrite;
-      }
-
-      if (sectorOffset == 0 && m_curPosition >= m_validLength) {
-        // start of new sector don't need to read into cache
-        cacheOption = FsCache::CACHE_RESERVE_FOR_WRITE;
-      } else {
-        // rewrite part of sector
-        cacheOption = FsCache::CACHE_FOR_WRITE;
-      }
-      cache = m_vol->dataCachePrepare(sector, cacheOption);
-      if (!cache) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      uint8_t* dst = cache + sectorOffset;
-      memcpy(dst, src, n);
-      if (m_vol->bytesPerSector() == (n + sectorOffset)) {
-        // Force write if sector is full - improves large writes.
-        if (!m_vol->dataCacheSync()) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-      }
-#if USE_MULTI_SECTOR_IO
-    } else if (toWrite >= 2*m_vol->bytesPerSector()) {
-      // use multiple sector write command
-      uint32_t ns = toWrite >> m_vol->bytesPerSectorShift();
-      // Limit writes to current cluster.
-      uint32_t maxNs = m_vol->sectorsPerCluster()
-                       - (clusterOffset >> m_vol->bytesPerSectorShift());
-      if (ns > maxNs) {
-        ns = maxNs;
-      }
-      n = ns << m_vol->bytesPerSectorShift();
-      if (!m_vol->cacheSafeWrite(sector, src, ns)) {
-         DBG_FAIL_MACRO;
-        goto fail;
-      }
-#endif  // USE_MULTI_SECTOR_IO
-    } else {
-      n = m_vol->bytesPerSector();
-      if (!m_vol->cacheSafeWrite(sector, src)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    m_curPosition += n;
-    src += n;
-    toWrite -= n;
-    if (m_curPosition > m_validLength) {
-      m_flags |= FILE_FLAG_DIR_DIRTY;
-      m_validLength = m_curPosition;
-    }
-  }
-  if (m_curPosition > m_dataLength) {
-    m_dataLength = m_curPosition;
-    // update fileSize and insure sync will update dir entry
-    m_flags |= FILE_FLAG_DIR_DIRTY;
-  } else if (FsDateTime::callback) {
-    // insure sync will update modified date and time
-    m_flags |= FILE_FLAG_DIR_DIRTY;
-  }
-  return nbyte;
-
- fail:
-  // return for write error
-  m_error |= WRITE_ERROR;
-  return 0;
-}
-#endif  // EXFAT_READ_ONLY

lib/SdFat_NoArduino/src/ExFatLib/ExFatFormatter.cpp

@@ -1,363 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "ExFatFormatter.cpp"
-#include "../common/DebugMacros.h"
-#include "../common/upcase.h"
-#include "ExFatLib.h"
-//------------------------------------------------------------------------------
-// Formatter assumes 512 byte sectors.
-const uint32_t BOOT_BACKUP_OFFSET = 12;
-const uint16_t BYTES_PER_SECTOR = 512;
-const uint16_t SECTOR_MASK = BYTES_PER_SECTOR - 1;
-const uint8_t  BYTES_PER_SECTOR_SHIFT = 9;
-const uint16_t MINIMUM_UPCASE_SKIP = 512;
-const uint32_t BITMAP_CLUSTER = 2;
-const uint32_t UPCASE_CLUSTER = 3;
-const uint32_t ROOT_CLUSTER = 4;
-//------------------------------------------------------------------------------
-#define PRINT_FORMAT_PROGRESS 1
-#if !PRINT_FORMAT_PROGRESS
-#define writeMsg(pr, str)
-#elif defined(__AVR__)
-#define writeMsg(pr, str) if (pr) pr->print(F(str))
-#else  // PRINT_FORMAT_PROGRESS
-#define writeMsg(pr, str) if (pr) pr->write(str)
-#endif  // PRINT_FORMAT_PROGRESS
-//------------------------------------------------------------------------------
-bool ExFatFormatter::format(FsBlockDevice* dev, uint8_t* secBuf, print_t* pr) {
-#if !PRINT_FORMAT_PROGRESS
-(void)pr;
-#endif  //  !PRINT_FORMAT_PROGRESS
-  MbrSector_t* mbr;
-  ExFatPbs_t* pbs;
-  DirUpcase_t* dup;
-  DirBitmap_t* dbm;
-  DirLabel_t* label;
-  uint32_t bitmapSize;
-  uint32_t checksum = 0;
-  uint32_t clusterCount;
-  uint32_t clusterHeapOffset;
-  uint32_t fatLength;
-  uint32_t fatOffset;
-  uint32_t m;
-  uint32_t ns;
-  uint32_t partitionOffset;
-  uint32_t sector;
-  uint32_t sectorsPerCluster;
-  uint32_t volumeLength;
-  uint32_t sectorCount;
-  uint8_t sectorsPerClusterShift;
-  uint8_t vs;
-
-  m_dev = dev;
-  m_secBuf = secBuf;
-  sectorCount = dev->sectorCount();
-  // Min size is 512 MB
-  if (sectorCount < 0X100000) {
-    writeMsg(pr, "Device is too small\r\n");
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Determine partition layout.
-  for (m = 1, vs = 0; m && sectorCount > m; m <<= 1, vs++) {}
-  sectorsPerClusterShift = vs < 29 ? 8 : (vs - 11)/2;
-  sectorsPerCluster = 1UL << sectorsPerClusterShift;
-  fatLength = 1UL << (vs < 27 ? 13 : (vs + 1)/2);
-  fatOffset = fatLength;
-  partitionOffset = 2*fatLength;
-  clusterHeapOffset = 2*fatLength;
-  clusterCount = (sectorCount - 4*fatLength) >> sectorsPerClusterShift;
-  volumeLength = clusterHeapOffset + (clusterCount << sectorsPerClusterShift);
-
-  // make Master Boot Record.  Use fake CHS.
-  memset(secBuf, 0, BYTES_PER_SECTOR);
-  mbr = reinterpret_cast<MbrSector_t*>(secBuf);
-  mbr->part->beginCHS[0] = 1;
-  mbr->part->beginCHS[1] = 1;
-  mbr->part->beginCHS[2] = 0;
-  mbr->part->type = 7;
-  mbr->part->endCHS[0] = 0XFE;
-  mbr->part->endCHS[1] = 0XFF;
-  mbr->part->endCHS[2] = 0XFF;
-  setLe32(mbr->part->relativeSectors, partitionOffset);
-  setLe32(mbr->part->totalSectors, volumeLength);
-  setLe16(mbr->signature, MBR_SIGNATURE);
-  if (!dev->writeSector(0, secBuf)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Partition Boot sector.
-  memset(secBuf, 0, BYTES_PER_SECTOR);
-  pbs = reinterpret_cast<ExFatPbs_t*>(secBuf);
-  pbs->jmpInstruction[0] = 0XEB;
-  pbs->jmpInstruction[1] = 0X76;
-  pbs->jmpInstruction[2] = 0X90;
-  pbs->oemName[0] = 'E';
-  pbs->oemName[1] = 'X';
-  pbs->oemName[2] = 'F';
-  pbs->oemName[3] = 'A';
-  pbs->oemName[4] = 'T';
-  pbs->oemName[5] = ' ';
-  pbs->oemName[6] = ' ';
-  pbs->oemName[7] = ' ';
-  setLe64(pbs->bpb.partitionOffset, partitionOffset);
-  setLe64(pbs->bpb.volumeLength, volumeLength);
-  setLe32(pbs->bpb.fatOffset, fatOffset);
-  setLe32(pbs->bpb.fatLength, fatLength);
-  setLe32(pbs->bpb.clusterHeapOffset, clusterHeapOffset);
-  setLe32(pbs->bpb.clusterCount, clusterCount);
-  setLe32(pbs->bpb.rootDirectoryCluster, ROOT_CLUSTER);
-  setLe32(pbs->bpb.volumeSerialNumber, sectorCount);
-  setLe16(pbs->bpb.fileSystemRevision, 0X100);
-  setLe16(pbs->bpb.volumeFlags, 0);
-  pbs->bpb.bytesPerSectorShift = BYTES_PER_SECTOR_SHIFT;
-  pbs->bpb.sectorsPerClusterShift = sectorsPerClusterShift;
-  pbs->bpb.numberOfFats = 1;
-  pbs->bpb.driveSelect = 0X80;
-  pbs->bpb.percentInUse = 0;
-
-  // Fill boot code like official SDFormatter.
-  for (size_t i = 0; i < sizeof(pbs->bootCode); i++) {
-    pbs->bootCode[i] = 0XF4;
-  }
-  setLe16(pbs->signature, PBR_SIGNATURE);
-  for (size_t i = 0; i < BYTES_PER_SECTOR; i++) {
-    if (i == offsetof(ExFatPbs_t, bpb.volumeFlags[0]) ||
-        i == offsetof(ExFatPbs_t, bpb.volumeFlags[1]) ||
-        i == offsetof(ExFatPbs_t, bpb.percentInUse)) {
-      continue;
-    }
-    checksum = exFatChecksum(checksum, secBuf[i]);
-  }
-  sector = partitionOffset;
-  if (!dev->writeSector(sector, secBuf)  ||
-      !dev->writeSector(sector + BOOT_BACKUP_OFFSET , secBuf)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  sector++;
-  // Write eight Extended Boot Sectors.
-  memset(secBuf, 0, BYTES_PER_SECTOR);
-  setLe16(pbs->signature, PBR_SIGNATURE);
-  for (int j = 0; j < 8; j++) {
-    for (size_t i = 0; i < BYTES_PER_SECTOR; i++) {
-      checksum = exFatChecksum(checksum, secBuf[i]);
-    }
-    if (!dev->writeSector(sector, secBuf)  ||
-        !dev->writeSector(sector + BOOT_BACKUP_OFFSET , secBuf)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    sector++;
-  }
-  // Write OEM Parameter Sector and reserved sector.
-  memset(secBuf, 0, BYTES_PER_SECTOR);
-  for (int j = 0; j < 2; j++) {
-    for (size_t i = 0; i < BYTES_PER_SECTOR; i++) {
-      checksum = exFatChecksum(checksum, secBuf[i]);
-    }
-    if (!dev->writeSector(sector, secBuf)  ||
-        !dev->writeSector(sector + BOOT_BACKUP_OFFSET , secBuf)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    sector++;
-  }
-  // Write Boot CheckSum Sector.
-  for (size_t i = 0; i < BYTES_PER_SECTOR; i += 4) {
-    setLe32(secBuf + i, checksum);
-  }
-  if (!dev->writeSector(sector, secBuf)  ||
-      !dev->writeSector(sector + BOOT_BACKUP_OFFSET , secBuf)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Initialize FAT.
-  writeMsg(pr, "Writing FAT ");
-  sector = partitionOffset + fatOffset;
-  ns = ((clusterCount + 2)*4 + BYTES_PER_SECTOR - 1)/BYTES_PER_SECTOR;
-
-  memset(secBuf, 0, BYTES_PER_SECTOR);
-  // Allocate two reserved clusters, bitmap, upcase, and root clusters.
-  secBuf[0] = 0XF8;
-  for (size_t i = 1; i < 20; i++) {
-    secBuf[i] = 0XFF;
-  }
-  for (uint32_t i = 0; i < ns; i++) {
-    if (i%(ns/32) == 0) {
-      writeMsg(pr, ".");
-    }
-    if (!dev->writeSector(sector + i, secBuf)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (i == 0) {
-      memset(secBuf, 0, BYTES_PER_SECTOR);
-    }
-  }
-  writeMsg(pr, "\r\n");
-  // Write cluster two, bitmap.
-  sector = partitionOffset + clusterHeapOffset;
-  bitmapSize = (clusterCount + 7)/8;
-  ns = (bitmapSize + BYTES_PER_SECTOR - 1)/BYTES_PER_SECTOR;
-  if (ns > sectorsPerCluster) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  memset(secBuf, 0, BYTES_PER_SECTOR);
-  // Allocate clusters for bitmap, upcase, and root.
-  secBuf[0] = 0X7;
-  for (uint32_t i = 0; i < ns; i++) {
-    if (!dev->writeSector(sector + i, secBuf)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (i == 0) {
-      secBuf[0] = 0;
-    }
-  }
-  // Write cluster three, upcase table.
-  writeMsg(pr, "Writing upcase table\r\n");
-  if (!writeUpcase(partitionOffset + clusterHeapOffset + sectorsPerCluster)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (m_upcaseSize > BYTES_PER_SECTOR*sectorsPerCluster) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Initialize first sector of root.
-  writeMsg(pr, "Writing root\r\n");
-  ns = sectorsPerCluster;
-  sector = partitionOffset + clusterHeapOffset + 2*sectorsPerCluster;
-  memset(secBuf, 0, BYTES_PER_SECTOR);
-
-  // Unused Label entry.
-  label = reinterpret_cast<DirLabel_t*>(secBuf);
-  label->type = EXFAT_TYPE_LABEL & 0X7F;
-
-  // bitmap directory entry.
-  dbm = reinterpret_cast<DirBitmap_t*>(secBuf + 32);
-  dbm->type = EXFAT_TYPE_BITMAP;
-  setLe32(dbm->firstCluster, BITMAP_CLUSTER);
-  setLe64(dbm->size, bitmapSize);
-
-  // upcase directory entry.
-  dup = reinterpret_cast<DirUpcase_t*>(secBuf + 64);
-  dup->type = EXFAT_TYPE_UPCASE;
-  setLe32(dup->checksum, m_upcaseChecksum);
-  setLe32(dup->firstCluster, UPCASE_CLUSTER);
-  setLe64(dup->size, m_upcaseSize);
-
-  // Write root, cluster four.
-  for (uint32_t i = 0; i < ns; i++) {
-    if (!dev->writeSector(sector + i, secBuf)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (i == 0) {
-      memset(secBuf, 0, BYTES_PER_SECTOR);
-    }
-  }
-  writeMsg(pr, "Format done\r\n");
-  return true;
-
- fail:
-  writeMsg(pr, "Format failed\r\n");
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatFormatter::syncUpcase() {
-  uint16_t index = m_upcaseSize & SECTOR_MASK;
-  if (!index) {
-    return true;
-  }
-  for (size_t i = index; i < BYTES_PER_SECTOR; i++) {
-    m_secBuf[i] = 0;
-  }
-  return m_dev->writeSector(m_upcaseSector, m_secBuf);
-}
-//------------------------------------------------------------------------------
-bool ExFatFormatter::writeUpcaseByte(uint8_t b) {
-  uint16_t index = m_upcaseSize & SECTOR_MASK;
-  m_secBuf[index] = b;
-  m_upcaseChecksum = exFatChecksum(m_upcaseChecksum, b);
-  m_upcaseSize++;
-  if (index == SECTOR_MASK) {
-    return m_dev->writeSector(m_upcaseSector++, m_secBuf);
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool ExFatFormatter::writeUpcaseUnicode(uint16_t unicode) {
-  return writeUpcaseByte(unicode) && writeUpcaseByte(unicode >> 8);
-}
-//------------------------------------------------------------------------------
-bool ExFatFormatter::writeUpcase(uint32_t sector) {
-  uint32_t n;
-  uint32_t ns;
-  uint32_t ch = 0;
-  uint16_t uc;
-
-  m_upcaseSize = 0;
-  m_upcaseChecksum = 0;
-  m_upcaseSector = sector;
-
-  while (ch < 0X10000) {
-    uc = toUpcase(ch);
-    if (uc != ch) {
-      if (!writeUpcaseUnicode(uc)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      ch++;
-    } else {
-      for (n = ch + 1; n < 0X10000 && n == toUpcase(n); n++) {}
-      ns = n - ch;
-      if (ns >= MINIMUM_UPCASE_SKIP) {
-        if (!writeUpcaseUnicode(0XFFFF) || !writeUpcaseUnicode(ns)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        ch = n;
-      } else {
-        while (ch < n) {
-          if (!writeUpcaseUnicode(ch++)) {
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-        }
-      }
-    }
-  }
-  if (!syncUpcase()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}

lib/SdFat_NoArduino/src/ExFatLib/ExFatFormatter.h

@@ -1,55 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef ExFatFormatter_h
-#define ExFatFormatter_h
-#include "../common/FsBlockDevice.h"
-/**
- * \class ExFatFormatter
- * \brief Format an exFAT volume.
- */
-class ExFatFormatter {
- public:
-  /**
-   * Format an exFAT volume.
-   *
-   * \param[in] dev Block device for volume.
-   * \param[in] secBuf buffer for writing to volume.
-   * \param[in] pr Print device for progress output.
-   *
-   * \return true for success or false for failure.
-   */
-  bool format(FsBlockDevice* dev, uint8_t* secBuf, print_t* pr = nullptr);
- private:
-  bool syncUpcase();
-  bool writeUpcase(uint32_t sector);
-  bool writeUpcaseByte(uint8_t b);
-  bool writeUpcaseUnicode(uint16_t unicode);
-  uint32_t m_upcaseSector;
-  uint32_t m_upcaseChecksum;
-  uint32_t m_upcaseSize;
-  FsBlockDevice* m_dev;
-  uint8_t* m_secBuf;
-};
-#endif  // ExFatFormatter_h

lib/SdFat_NoArduino/src/ExFatLib/ExFatLib.h

@@ -1,29 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef ExFatLib_h
-#define ExFatLib_h
-#include "ExFatVolume.h"
-#include "ExFatFormatter.h"
-#endif  // ExFatLib_h

lib/SdFat_NoArduino/src/ExFatLib/ExFatName.cpp

@@ -1,194 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "ExFatName.cpp"
-#include "../common/DebugMacros.h"
-#include "../common/upcase.h"
-#include "../common/FsUtf.h"
-#include "ExFatLib.h"
-//------------------------------------------------------------------------------
-static char toUpper(char c) {
-  return 'a' <= c && c <= 'z' ? c - 'a' + 'A' : c;
-}
-//------------------------------------------------------------------------------
-inline uint16_t exFatHash(char c, uint16_t hash) {
-  uint8_t u = toUpper(c);
-  hash = ((hash << 15) | (hash >> 1)) + u;
-  hash = ((hash << 15) | (hash >> 1));
-  return hash;
-}
-//------------------------------------------------------------------------------
-inline uint16_t exFatHash(uint16_t u, uint16_t hash) {
-  uint16_t c = toUpcase(u);
-  hash = ((hash << 15) | (hash >> 1)) + (c & 0XFF);
-  hash = ((hash << 15) | (hash >> 1)) + (c >> 8);
-  return hash;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::cmpName(const DirName_t* dirName, ExName_t* fname) {
-  for (uint8_t i = 0; i < 15; i++) {
-    uint16_t u = getLe16(dirName->unicode + 2*i);
-    if (fname->atEnd()) {
-      return u == 0;
-    }
-#if USE_UTF8_LONG_NAMES
-    uint16_t cp = fname->get16();
-    if (toUpcase(cp) != toUpcase(u)) {
-       return false;
-    }
-#else  // USE_UTF8_LONG_NAMES
-    char c = fname->getch();
-    if (u >= 0x7F || toUpper(c) != toUpper(u)) {
-      return false;
-    }
-#endif  // USE_UTF8_LONG_NAMES
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::getName7(char* name, size_t count) {
-  DirName_t* dn;
-  size_t n = 0;
-  if (!isOpen()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-  for (uint8_t is = 2; is <= m_setCount; is++) {
-    dn = reinterpret_cast<DirName_t*>
-         (dirCache(is, FsCache::CACHE_FOR_READ));
-    if (!dn || dn->type != EXFAT_TYPE_NAME) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (uint8_t in = 0; in < 15; in++) {
-      uint16_t c = getLe16(dn->unicode + 2*in);
-      if (c == 0) {
-        goto done;
-      }
-      if ((n + 1) >= count) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      name[n++] = c < 0X7F ? c : '?';
-    }
-  }
- done:
-  name[n] = 0;
-  return n;
-
- fail:
-  *name = 0;
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t ExFatFile::getName8(char* name, size_t count) {
-  char* end = name + count;
-  char* str = name;
-  char* ptr;
-  DirName_t* dn;
-  uint16_t hs = 0;
-  uint32_t cp;
-  if (!isOpen()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-  for (uint8_t is = 2; is <= m_setCount; is++) {
-    dn = reinterpret_cast<DirName_t*>
-         (dirCache(is, FsCache::CACHE_FOR_READ));
-    if (!dn || dn->type != EXFAT_TYPE_NAME) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (uint8_t in = 0; in < 15; in++) {
-      uint16_t c = getLe16(dn->unicode + 2*in);
-      if (hs) {
-        if (!FsUtf::isLowSurrogate(c)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        cp = FsUtf::u16ToCp(hs, c);
-        hs = 0;
-      } else if (!FsUtf::isSurrogate(c)) {
-        if (c == 0) {
-          goto done;
-        }
-        cp = c;
-      } else if (FsUtf::isHighSurrogate(c)) {
-        hs = c;
-        continue;
-      } else {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      // Save space for zero byte.
-      ptr = FsUtf::cpToMb(cp, str, end - 1);
-      if (!ptr) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      str = ptr;
-    }
-  }
- done:
-  *str = '\0';
-  return str - name;
-
- fail:
-  *name = 0;
-  return 0;
-}
-//------------------------------------------------------------------------------
-bool ExFatFile::hashName(ExName_t* fname) {
-  uint16_t hash = 0;
-  fname->reset();
-#if USE_UTF8_LONG_NAMES
-  fname->nameLength = 0;
-  while (!fname->atEnd()) {
-    uint16_t u = fname->get16();
-    if (u == 0XFFFF) {
-    DBG_FAIL_MACRO;
-      goto fail;
-    }
-    hash = exFatHash(u, hash);
-    fname->nameLength++;
-  }
-#else  // USE_UTF8_LONG_NAMES
-  while (!fname->atEnd()) {
-    // Convert to byte for smaller exFatHash.
-    char c = fname->getch();
-    hash = exFatHash(c, hash);
-  }
-  fname->nameLength = fname->end - fname->begin;
-#endif  // USE_UTF8_LONG_NAMES
-  fname->nameHash = hash;
-  if (!fname->nameLength || fname->nameLength > EXFAT_MAX_NAME_LENGTH) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-

lib/SdFat_NoArduino/src/ExFatLib/ExFatPartition.cpp

@@ -1,322 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "ExFatPartition.cpp"
-#include "../common/DebugMacros.h"
-#include "../common/PartitionTable.h"
-#include "ExFatLib.h"
-//------------------------------------------------------------------------------
-// return 0 if error, 1 if no space, else start cluster.
-uint32_t ExFatPartition::bitmapFind(uint32_t cluster, uint32_t count) {
-  uint32_t start = cluster ? cluster - 2 : m_bitmapStart;
-  if (start >= m_clusterCount) {
-    start = 0;
-  }
-  uint32_t endAlloc = start;
-  uint32_t bgnAlloc = start;
-  uint16_t sectorSize = 1 << m_bytesPerSectorShift;
-  size_t i = (start >> 3) & (sectorSize - 1);
-  uint8_t* cache;
-  uint8_t mask = 1 << (start & 7);
-  while (true) {
-    uint32_t sector = m_clusterHeapStartSector +
-                     (endAlloc >> (m_bytesPerSectorShift + 3));
-    cache = bitmapCachePrepare(sector, FsCache::CACHE_FOR_READ);
-    if (!cache) {
-      return 0;
-    }
-    for (; i < sectorSize; i++) {
-      for (; mask; mask <<= 1) {
-        endAlloc++;
-        if (!(mask & cache[i])) {
-          if ((endAlloc - bgnAlloc) == count) {
-            if (cluster == 0 && count == 1) {
-              // Start at found sector.  bitmapModify may increase this.
-              m_bitmapStart = bgnAlloc;
-            }
-            return bgnAlloc + 2;
-          }
-        } else {
-          bgnAlloc = endAlloc;
-        }
-        if (endAlloc == start) {
-          return 1;
-        }
-        if (endAlloc >= m_clusterCount) {
-          endAlloc = bgnAlloc = 0;
-          i = sectorSize;
-          break;
-        }
-      }
-      mask = 1;
-    }
-    i = 0;
-  }
-  return 0;
-}
-//------------------------------------------------------------------------------
-bool ExFatPartition::bitmapModify(uint32_t cluster,
-                                  uint32_t count, bool value) {
-  uint32_t sector;
-  uint32_t start = cluster - 2;
-  size_t i;
-  uint8_t* cache;
-  uint8_t mask;
-  cluster -= 2;
-  if ((start + count) > m_clusterCount) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (value) {
-    if (start  <= m_bitmapStart && m_bitmapStart < (start + count)) {
-      m_bitmapStart = (start + count) < m_clusterCount ? start + count : 0;
-    }
-  } else {
-    if (start < m_bitmapStart) {
-      m_bitmapStart = start;
-    }
-  }
-  mask = 1 << (start & 7);
-  sector = m_clusterHeapStartSector +
-                   (start >> (m_bytesPerSectorShift + 3));
-  i = (start >> 3) & m_sectorMask;
-  while (true) {
-    cache = bitmapCachePrepare(sector++, FsCache::CACHE_FOR_WRITE);
-    if (!cache) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (; i < m_bytesPerSector; i++) {
-      for (; mask; mask <<= 1) {
-        if (value == static_cast<bool>(cache[i] & mask)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        cache[i] ^= mask;
-        if (--count == 0) {
-          return true;
-        }
-      }
-      mask = 1;
-    }
-    i = 0;
-  }
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-uint32_t ExFatPartition::chainSize(uint32_t cluster) {
-  uint32_t n = 0;
-  int8_t status;
-  do {
-    status = fatGet(cluster, & cluster);
-    if (status < 0) return 0;
-    n++;
-  } while (status);
-  return n;
-}
-//------------------------------------------------------------------------------
-uint8_t* ExFatPartition::dirCache(DirPos_t* pos, uint8_t options) {
-  uint32_t sector = clusterStartSector(pos->cluster);
-  sector += (m_clusterMask & pos->position) >> m_bytesPerSectorShift;
-  uint8_t* cache = dataCachePrepare(sector, options);
-  return cache ? cache + (pos->position & m_sectorMask) : nullptr;
-}
-//------------------------------------------------------------------------------
-// return -1 error, 0 EOC, 1 OK
-int8_t ExFatPartition::dirSeek(DirPos_t* pos, uint32_t offset) {
-  int8_t status;
-  uint32_t tmp = (m_clusterMask & pos->position) + offset;
-  pos->position += offset;
-  tmp >>= bytesPerClusterShift();
-  while (tmp--) {
-    if (pos->isContiguous) {
-      pos->cluster++;
-    } else {
-      status = fatGet(pos->cluster, &pos->cluster);
-      if (status != 1) {
-        return status;
-      }
-    }
-  }
-  return 1;
-}
-//------------------------------------------------------------------------------
-// return -1 error, 0 EOC, 1 OK
-int8_t ExFatPartition::fatGet(uint32_t cluster, uint32_t* value) {
-  uint8_t* cache;
-  uint32_t next;
-  uint32_t sector;
-
-  if (cluster > (m_clusterCount + 1)) {
-    DBG_FAIL_MACRO;
-    return -1;
-  }
-  sector = m_fatStartSector + (cluster >> (m_bytesPerSectorShift - 2));
-
-  cache = dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
-  if (!cache) {
-    return -1;
-  }
-  next = getLe32(cache + ((cluster << 2) & m_sectorMask));
-  if (next == EXFAT_EOC) {
-    return 0;
-  }
-  *value = next;
-  return 1;
-}
-//------------------------------------------------------------------------------
-bool ExFatPartition::fatPut(uint32_t cluster, uint32_t value) {
-  uint32_t sector;
-  uint8_t* cache;
-  if (cluster < 2 || cluster > (m_clusterCount + 1)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  sector = m_fatStartSector + (cluster >> (m_bytesPerSectorShift - 2));
-  cache = dataCachePrepare(sector, FsCache::CACHE_FOR_WRITE);
-  if (!cache) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  setLe32(cache + ((cluster << 2) & m_sectorMask), value);
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool ExFatPartition::freeChain(uint32_t cluster) {
-  uint32_t next;
-  uint32_t start = cluster;
-  int8_t status;
-  do {
-    status = fatGet(cluster, &next);
-    if (status < 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (!fatPut(cluster, 0)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (status == 0 || (cluster + 1) != next) {
-      if (!bitmapModify(start, cluster - start + 1, 0)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      start = next;
-    }
-    cluster = next;
-  } while (status);
-
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-int32_t ExFatPartition::freeClusterCount() {
-  uint32_t nc = 0;
-  uint32_t sector = m_clusterHeapStartSector;
-  uint32_t usedCount = 0;
-  uint8_t* cache;
-
-  while (true) {
-    cache = dataCachePrepare(sector++, FsCache::CACHE_FOR_READ);
-    if (!cache) {
-      return -1;
-    }
-    for (size_t i = 0; i < m_bytesPerSector; i++) {
-      if (cache[i] == 0XFF) {
-        usedCount+= 8;
-      } else if (cache[i]) {
-        for (uint8_t mask = 1; mask ; mask <<=1) {
-          if ((mask & cache[i])) {
-            usedCount++;
-          }
-        }
-      }
-      nc += 8;
-      if (nc >= m_clusterCount) {
-        return m_clusterCount - usedCount;
-      }
-    }
-  }
-}
-//------------------------------------------------------------------------------
-bool ExFatPartition::init(FsBlockDevice* dev, uint8_t part, uint32_t volStart) {
-  pbs_t* pbs;
-  BpbExFat_t* bpb;
-  m_fatType = 0;
-  m_blockDev = dev;
-  cacheInit(m_blockDev);
-  // if part == 0 assume super floppy with FAT boot sector in sector zero
-  // if part > 0 read MBR / GPT partition table
-  if (part) {
-    volStart = partitionTableGetVolumeStartSector(m_dataCache, part);
-
-    if (!volStart) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  pbs = reinterpret_cast<pbs_t*>
-        (dataCachePrepare(volStart, FsCache::CACHE_FOR_READ));
-  if (!pbs) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (strncmp(pbs->oemName, "EXFAT", 5)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  bpb = reinterpret_cast<BpbExFat_t*>(pbs->bpb);
-  if (bpb->bytesPerSectorShift != m_bytesPerSectorShift) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_fatStartSector = volStart + getLe32(bpb->fatOffset);
-  m_fatLength = getLe32(bpb->fatLength);
-  m_clusterHeapStartSector = volStart + getLe32(bpb->clusterHeapOffset);
-  m_clusterCount = getLe32(bpb->clusterCount);
-  m_rootDirectoryCluster = getLe32(bpb->rootDirectoryCluster);
-  m_sectorsPerClusterShift = bpb->sectorsPerClusterShift;
-  m_bytesPerCluster = 1UL << (m_bytesPerSectorShift + m_sectorsPerClusterShift);
-  m_clusterMask = m_bytesPerCluster - 1;
-  // Set m_bitmapStart to first free cluster.
-  m_bitmapStart = 0;
-  bitmapFind(0, 1);
-  m_fatType = FAT_TYPE_EXFAT;
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-uint32_t ExFatPartition::rootLength() {
-  uint32_t nc = chainSize(m_rootDirectoryCluster);
-  return nc << bytesPerClusterShift();
-}

lib/SdFat_NoArduino/src/ExFatLib/ExFatPartition.h

@@ -1,231 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef ExFatPartition_h
-#define ExFatPartition_h
-/**
- * \file
- * \brief ExFatPartition include file.
- */
-#include "../common/SysCall.h"
-#include "../common/FsBlockDevice.h"
-#include "../common/FsCache.h"
-#include "../common/FsStructs.h"
-/** Set EXFAT_READ_ONLY non-zero for read only */
-#ifndef EXFAT_READ_ONLY
-#define EXFAT_READ_ONLY 0
-#endif  // EXFAT_READ_ONLY
-/** Type for exFAT partition */
-const uint8_t FAT_TYPE_EXFAT = 64;
-
-class ExFatFile;
-//------------------------------------------------------------------------------
-/**
- * \struct DirPos_t
- * \brief Internal type for position in directory file.
- */
-struct DirPos_t {
-  /** current cluster */
-  uint32_t cluster;
-  /** offset */
-  uint32_t position;
-  /** directory is contiguous */
-  bool     isContiguous;
-};
-//==============================================================================
-/**
- * \class ExFatPartition
- * \brief Access exFat partitions on raw file devices.
- */
-class ExFatPartition {
- public:
-  ExFatPartition() {}
-  /** \return the number of bytes in a cluster. */
-  uint32_t bytesPerCluster() const {return m_bytesPerCluster;}
-  /** \return the power of two for bytesPerCluster. */
-  uint8_t bytesPerClusterShift() const {
-    return m_bytesPerSectorShift + m_sectorsPerClusterShift;
-  }
-  /** \return the number of bytes in a sector. */
-  uint16_t bytesPerSector() const {return m_bytesPerSector;}
-  /** \return the power of two for bytesPerSector. */
-  uint8_t bytesPerSectorShift() const {return m_bytesPerSectorShift;}
-
-  /** Clear the cache and returns a pointer to the cache.  Not for normal apps.
-   * \return A pointer to the cache buffer or zero if an error occurs.
-   */
-  uint8_t* cacheClear() {
-    return m_dataCache.clear();
-  }
-  /** \return the cluster count for the partition. */
-  uint32_t clusterCount() const {return m_clusterCount;}
-  /** \return the cluster heap start sector. */
-  uint32_t clusterHeapStartSector() const {return m_clusterHeapStartSector;}
-  /** End access to volume
-   * \return pointer to sector size buffer for format.
-   */
-  uint8_t* end() {
-    m_fatType = 0;
-    return cacheClear();
-  }
-  /** \return the FAT length in sectors */
-  uint32_t fatLength() const {return m_fatLength;}
-  /** \return the FAT start sector number. */
-  uint32_t fatStartSector() const {return m_fatStartSector;}
-  /** \return Type FAT_TYPE_EXFAT for exFAT partition or zero for error. */
-  uint8_t fatType() const {return m_fatType;}
-  /** \return free cluster count or -1 if an error occurs. */
-  int32_t freeClusterCount();
-  /** Initialize a exFAT partition.
-   * \param[in] dev The blockDevice for the partition.
-   * \param[in] part The partition to be used.  Legal values for \a part are
-   * 1-4 to use the corresponding partition on a device formatted with
-   * a MBR, Master Boot Record, or zero if the device is formatted as
-   * a super floppy with the FAT boot sector in sector volStart.
-   * \param[in] volStart location of volume if part is zero.
-   *
-   * \return true for success or false for failure.
-   */
-  bool init(FsBlockDevice* dev, uint8_t part, uint32_t volStart = 0);
-  /**
-   * Check for device busy.
-   *
-   * \return true if busy else false.
-   */
-  bool isBusy() {return m_blockDev->isBusy();}
-  /** \return the root directory start cluster number. */
-  uint32_t rootDirectoryCluster() const {return m_rootDirectoryCluster;}
-  /** \return the root directory length. */
-  uint32_t rootLength();
-  /** \return the number of sectors in a cluster. */
-  uint32_t sectorsPerCluster() const {return 1UL << m_sectorsPerClusterShift;}
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  uint32_t __attribute__((error("use sectorsPerCluster()"))) blocksPerCluster();
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  /** \return the power of two for sectors per cluster. */
-  uint8_t  sectorsPerClusterShift() const {return m_sectorsPerClusterShift;}
-  //----------------------------------------------------------------------------
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  void checkUpcase(print_t* pr);
-  bool printDir(print_t* pr, ExFatFile* file);
-  void dmpBitmap(print_t* pr);
-  void dmpCluster(print_t* pr, uint32_t cluster,
-                  uint32_t offset, uint32_t count);
-  void dmpFat(print_t* pr, uint32_t start, uint32_t count);
-  void dmpSector(print_t* pr, uint32_t sector);
-  bool printVolInfo(print_t* pr);
-  void printFat(print_t* pr);
-  void printUpcase(print_t* pr);
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  //----------------------------------------------------------------------------
- private:
-  /** ExFatFile allowed access to private members. */
-  friend class ExFatFile;
-  uint32_t bitmapFind(uint32_t cluster, uint32_t count);
-  bool bitmapModify(uint32_t cluster, uint32_t count, bool value);
-  //----------------------------------------------------------------------------
-  // Cache functions.
-  uint8_t* bitmapCachePrepare(uint32_t sector, uint8_t option) {
-#if USE_EXFAT_BITMAP_CACHE
-    return m_bitmapCache.prepare(sector, option);
-#else  // USE_EXFAT_BITMAP_CACHE
-    return m_dataCache.prepare(sector, option);
-#endif  // USE_EXFAT_BITMAP_CACHE
-  }
-  void cacheInit(FsBlockDevice* dev) {
-#if USE_EXFAT_BITMAP_CACHE
-    m_bitmapCache.init(dev);
-#endif  // USE_EXFAT_BITMAP_CACHE
-    m_dataCache.init(dev);
-  }
-  bool cacheSync() {
-#if USE_EXFAT_BITMAP_CACHE
-    return m_bitmapCache.sync() && m_dataCache.sync() && syncDevice();
-#else  // USE_EXFAT_BITMAP_CACHE
-    return m_dataCache.sync() && syncDevice();
-#endif  // USE_EXFAT_BITMAP_CACHE
-  }
-  void dataCacheDirty() {m_dataCache.dirty();}
-  void dataCacheInvalidate() {m_dataCache.invalidate();}
-  uint8_t* dataCachePrepare(uint32_t sector, uint8_t option) {
-    return m_dataCache.prepare(sector, option);
-  }
-  uint32_t dataCacheSector() {return m_dataCache.sector();}
-  bool dataCacheSync() {return m_dataCache.sync();}
-  //----------------------------------------------------------------------------
-  uint32_t clusterMask() const {return m_clusterMask;}
-  uint32_t clusterStartSector(uint32_t cluster) {
-    return m_clusterHeapStartSector +
-           ((cluster - 2) << m_sectorsPerClusterShift);
-  }
-  uint8_t* dirCache(DirPos_t* pos, uint8_t options);
-  int8_t dirSeek(DirPos_t* pos, uint32_t offset);
-  int8_t fatGet(uint32_t cluster, uint32_t* value);
-  bool fatPut(uint32_t cluster, uint32_t value);
-  uint32_t chainSize(uint32_t cluster);
-  bool freeChain(uint32_t cluster);
-  uint16_t sectorMask() const {return m_sectorMask;}
-  bool syncDevice() {
-    return m_blockDev->syncDevice();
-  }
-  bool cacheSafeRead(uint32_t sector, uint8_t* dst) {
-    return m_dataCache.cacheSafeRead(sector, dst);
-  }
-  bool cacheSafeWrite(uint32_t sector, const uint8_t* src) {
-    return m_dataCache.cacheSafeWrite(sector, src);
-  }
-  bool cacheSafeRead(uint32_t sector, uint8_t* dst, size_t count) {
-    return m_dataCache.cacheSafeRead(sector, dst, count);
-  }
-  bool cacheSafeWrite(uint32_t sector, const uint8_t* src, size_t count) {
-     return m_dataCache.cacheSafeWrite(sector, src, count);
-  }
-  bool readSector(uint32_t sector, uint8_t* dst) {
-    return m_blockDev->readSector(sector, dst);
-  }
-  bool writeSector(uint32_t sector, const uint8_t* src) {
-    return m_blockDev->writeSector(sector, src);
-  }
-  //----------------------------------------------------------------------------
-  static const uint8_t  m_bytesPerSectorShift = 9;
-  static const uint16_t m_bytesPerSector = 1 << m_bytesPerSectorShift;
-  static const uint16_t m_sectorMask = m_bytesPerSector - 1;
-  //----------------------------------------------------------------------------
-#if USE_EXFAT_BITMAP_CACHE
-  FsCache  m_bitmapCache;
-#endif  // USE_EXFAT_BITMAP_CACHE
-  FsCache  m_dataCache;
-  uint32_t m_bitmapStart;
-  uint32_t m_fatStartSector;
-  uint32_t m_fatLength;
-  uint32_t m_clusterHeapStartSector;
-  uint32_t m_clusterCount;
-  uint32_t m_rootDirectoryCluster;
-  uint32_t m_clusterMask;
-  uint32_t m_bytesPerCluster;
-  FsBlockDevice* m_blockDev;
-  uint8_t  m_fatType = 0;
-  uint8_t  m_sectorsPerClusterShift;
-};
-#endif  // ExFatPartition_h

lib/SdFat_NoArduino/src/ExFatLib/ExFatVolume.cpp

@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "ExFatVolume.cpp"
-#include "../common/DebugMacros.h"
-#include "ExFatLib.h"
-ExFatVolume* ExFatVolume::m_cwv = nullptr;
-//-----------------------------------------------------------------------------
-bool ExFatVolume::chdir(const char* path) {
-  ExFatFile dir;
-  if (!dir.open(vwd(), path, O_RDONLY)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!dir.isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_vwd = dir;
-  return true;
-
- fail:
-  return false;
-}

lib/SdFat_NoArduino/src/ExFatLib/ExFatVolume.h

@@ -1,357 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef ExFatVolume_h
-#define ExFatVolume_h
-#include "ExFatFile.h"
-//==============================================================================
-/**
- * \class ExFatVolume
- * \brief exFAT volume.
- */
-class ExFatVolume : public ExFatPartition {
- public:
-  ExFatVolume() {}
-  /** Get file's user settable attributes.
-   * \param[in] path path to file.
-   * \return user settable file attributes for success else -1.
-   */
-  int attrib(const char* path) {
-    ExFatFile tmpFile;
-    return tmpFile.open(this, path, O_RDONLY) ? tmpFile.attrib() : -1;
-  }
-  /** Set file's user settable attributes.
-   * \param[in] path path to file.
-   * \param[in] bits bit-wise or of selected attributes: FS_ATTRIB_READ_ONLY,
-   *            FS_ATTRIB_HIDDEN, FS_ATTRIB_SYSTEM, FS_ATTRIB_ARCHIVE.
-   *
-   * \return true for success or false for failure.
-   */
-  bool attrib(const char* path, uint8_t bits) {
-    ExFatFile tmpFile;
-    return tmpFile.open(this, path, O_RDONLY) ? tmpFile.attrib(bits) : false;
-  }
-  /**
-   * Initialize an FatVolume object.
-   * \param[in] dev Device block driver.
-   * \param[in] setCwv Set current working volume if true.
-   * \param[in] part Partition to initialize.
-   * \param[in] volStart Start sector of volume if part is zero.
-   * \return true for success or false for failure.
-   */
-  bool begin(FsBlockDevice* dev, bool setCwv = true,
-             uint8_t part = 1, uint32_t volStart = 0) {
-    if (!init(dev, part, volStart)) {
-      return false;
-    }
-    if (!chdir()) {
-      return false;
-    }
-    if (setCwv || !m_cwv) {
-      m_cwv = this;
-    }
-    return true;
-  }
-  /**
-   * Set volume working directory to root.
-   * \return true for success or false for failure.
-   */
-  bool chdir() {
-    m_vwd.close();
-    return m_vwd.openRoot(this);
-  }
-  /**
-   * Set volume working directory.
-   * \param[in] path Path for volume working directory.
-   * \return true for success or false for failure.
-   */
-  bool chdir(const char* path);
-
-  /** Change global working volume to this volume. */
-  void chvol() {m_cwv = this;}
-
-  /**
-   * Test for the existence of a file.
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * \return true if the file exists else false.
-   */
-  bool exists(const char* path) {
-    ExFatFile tmp;
-    return tmp.open(this, path, O_RDONLY);
-  }
-  //----------------------------------------------------------------------------
-  /** List the directory contents of the root directory.
-   *
-   * \param[in] pr Print stream for list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, uint8_t flags = 0) {
-    return m_vwd.ls(pr, flags);
-  }
-  /** List the contents of a directory.
-   *
-   * \param[in] pr Print stream for list.
-   *
-   * \param[in] path directory to list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, const char* path, uint8_t flags) {
-    ExFatFile dir;
-    return dir.open(this, path, O_RDONLY) && dir.ls(pr, flags);
-  }
-  /** Make a subdirectory in the volume root directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(const char* path, bool pFlag = true) {
-    ExFatFile sub;
-    return sub.mkdir(vwd(), path, pFlag);
-  }
-  /** open a file
-   *
-   * \param[in] path location of file to be opened.
-   * \param[in] oflag open flags.
-   * \return a ExFile object.
-   */
-  ExFile open(const char* path, oflag_t oflag = O_RDONLY) {
-    ExFile tmpFile;
-    tmpFile.open(this, path, oflag);
-    return tmpFile;
-  }
-  /** Remove a file from the volume root directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove(const char* path) {
-    ExFatFile tmp;
-    return tmp.open(this, path, O_WRONLY) && tmp.remove();
-  }
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] oldPath Path name to the file or subdirectory to be renamed.
-   *
-   * \param[in] newPath New path name of the file or subdirectory.
-   *
-   * The \a newPath object must not exist before the rename call.
-   *
-   * The file to be renamed must not be open.  The directory entry may be
-   * moved and file system corruption could occur if the file is accessed by
-   * a file object that was opened before the rename() call.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const char* oldPath, const char* newPath) {
-    ExFatFile file;
-    return file.open(vwd(), oldPath, O_RDONLY) && file.rename(vwd(), newPath);
-  }
-  /** Remove a subdirectory from the volume's working directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
-   *
-   * The subdirectory file will be removed only if it is empty.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir(const char* path) {
-    ExFatFile sub;
-    return sub.open(this, path, O_RDONLY) && sub.rmdir();
-  }
-  /** Truncate a file to a specified length.  The current file position
-   * will be at the new EOF.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the file.
-   * \param[in] length The desired length for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate(const char* path, uint64_t length) {
-    ExFatFile file;
-    if (!file.open(this, path, O_WRONLY)) {
-      return false;
-    }
-    return file.truncate(length);
-  }
-#if ENABLE_ARDUINO_SERIAL
-  /** List the directory contents of the root directory to Serial.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls() {
-    return ls(&Serial);
-  }
-   /** List the directory contents of the volume root to Serial.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(uint8_t flags) {
-    return ls(&Serial, flags);
-  }
-  /** List the directory contents of a directory to Serial.
-   *
-   * \param[in] path directory to list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(const char* path, uint8_t flags = 0) {
-    return ls(&Serial, path, flags);
-  }
-#endif  // ENABLE_ARDUINO_SERIAL
-#if ENABLE_ARDUINO_STRING
-  /**
-   * Set volume working directory.
-   * \param[in] path Path for volume working directory.
-   * \return true for success or false for failure.
-   */
-  bool chdir(const String& path) {
-    return chdir(path.c_str());
-  }
-  /** Test for the existence of a file in a directory
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * \return true if the file exists else false.
-   */
-  bool exists(const String &path) {
-    return exists(path.c_str());
-  }
-  /** Make a subdirectory in the volume root directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(const String &path, bool pFlag = true) {
-    return mkdir(path.c_str(), pFlag);
-  }
-  /** open a file
-   *
-   * \param[in] path location of file to be opened.
-   * \param[in] oflag open oflag flags.
-   * \return a ExFile object.
-   */
-  ExFile open(const String &path, oflag_t oflag = O_RDONLY) {
-    return open(path.c_str(), oflag);
-  }
-  /** Remove a file from the volume root directory.
-   *
-   * \param[in] path A path with a valid name for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove(const String& path) {
-    return remove(path.c_str());
-  }
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] oldPath Path name to the file or subdirectory to be renamed.
-   *
-   * \param[in] newPath New path name of the file or subdirectory.
-   *
-   * The \a newPath object must not exist before the rename call.
-   *
-   * The file to be renamed must not be open.  The directory entry may be
-   * moved and file system corruption could occur if the file is accessed by
-   * a file object that was opened before the rename() call.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const String& oldPath, const String& newPath) {
-    return rename(oldPath.c_str(), newPath.c_str());
-  }
-  /** Remove a subdirectory from the volume's working directory.
-   *
-   * \param[in] path A path with a valid name for the subdirectory.
-   *
-   * The subdirectory file will be removed only if it is empty.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir(const String& path) {
-    return rmdir(path.c_str());
-  }
-  /** Truncate a file to a specified length.  The current file position
-   * will be at the new EOF.
-   *
-   * \param[in] path A path with a valid name for the file.
-   * \param[in] length The desired length for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate(const String& path, uint64_t length) {
-    return truncate(path.c_str(), length);
-  }
-#endif  // ENABLE_ARDUINO_STRING
-
- private:
-  friend ExFatFile;
-  static ExFatVolume* cwv() {return m_cwv;}
-  ExFatFile* vwd() {return &m_vwd;}
-  static ExFatVolume* m_cwv;
-  ExFatFile m_vwd;
-};
-#endif  // ExFatVolume_h

lib/SdFat_NoArduino/src/FatLib/FatDbg.cpp

@@ -1,268 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FatLib.h"
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-//------------------------------------------------------------------------------
-static uint16_t getLfnChar(DirLfn_t* ldir, uint8_t i) {
-  if (i < 5) {
-    return getLe16(ldir->unicode1 + 2*i);
-  } else if (i < 11) {
-    return getLe16(ldir->unicode2 + 2*i - 10);
-  } else if (i < 13) {
-    return getLe16(ldir->unicode3 + 2*i - 22);
-  }
-  return 0;
-}
-//------------------------------------------------------------------------------
-static void printHex(print_t* pr, uint8_t h) {
-  if (h < 16) {
-    pr->write('0');
-  }
-  pr->print(h, HEX);
-}
-//------------------------------------------------------------------------------
-static void printHex(print_t* pr, uint8_t w, uint16_t h) {
-  char buf[5];
-  char* ptr = buf + sizeof(buf);
-  *--ptr = 0;
-  for (uint8_t i = 0; i < w; i++) {
-    char c = h & 0XF;
-    *--ptr = c < 10 ? c + '0' : c + 'A' - 10;
-    h >>= 4;
-  }
-  pr->write(ptr);
-}
-//------------------------------------------------------------------------------
-static void printHex(print_t* pr, uint16_t val) {
-  bool space = true;
-  for (uint8_t i = 0; i < 4; i++) {
-    uint8_t h = (val >> (12 - 4*i)) & 15;
-    if (h || i == 3) {
-      space = false;
-    }
-    if (space) {
-      pr->write(' ');
-    } else {
-      pr->print(h, HEX);
-    }
-  }
-}
-//------------------------------------------------------------------------------
-static void printHex(print_t* pr, uint32_t val) {
-  bool space = true;
-  for (uint8_t i = 0; i < 8; i++) {
-    uint8_t h = (val >> (28 - 4*i)) & 15;
-    if (h || i == 7) {
-      space = false;
-    }
-    if (space) {
-      pr->write(' ');
-    } else {
-      pr->print(h, HEX);
-    }
-  }
-}
-//------------------------------------------------------------------------------
-template<typename Uint>
-static void printHexLn(print_t* pr, Uint val) {
-  printHex(pr, val);
-  pr->println();
-}
-//------------------------------------------------------------------------------
-static bool printFatDir(print_t* pr, DirFat_t* dir) {
-  DirLfn_t* ldir = reinterpret_cast<DirLfn_t*>(dir);
-  if (!dir->name[0]) {
-    pr->println(F("Unused"));
-    return false;
-  } else if (dir->name[0] == FAT_NAME_DELETED) {
-    pr->println(F("Deleted"));
-  } else if (isFatFileOrSubdir(dir)) {
-    pr->print(F("SFN: "));
-    for (uint8_t i = 0; i < 11; i++) {
-      printHex(pr, dir->name[i]);
-      pr->write(' ');
-    }
-    pr->write(' ');
-    pr->write(dir->name, 11);
-    pr->println();
-    pr->print(F("attributes: 0X"));
-    printHexLn(pr, dir->attributes);
-    pr->print(F("caseFlags: 0X"));
-    printHexLn(pr, dir->caseFlags);
-    uint32_t fc = ((uint32_t)getLe16(dir->firstClusterHigh) << 16)
-                 | getLe16(dir->firstClusterLow);
-    pr->print(F("firstCluster: "));
-    pr->println(fc, HEX);
-    pr->print(F("fileSize: "));
-    pr->println(getLe32(dir->fileSize));
-  } else if (isFatLongName(dir)) {
-    pr->print(F("LFN: "));
-    for (uint8_t i = 0; i < 13; i++) {
-      uint16_t c = getLfnChar(ldir, i);
-      if (15 < c && c < 128) {
-        pr->print(static_cast<char>(c));
-      } else {
-        pr->print("0X");
-        pr->print(c, HEX);
-      }
-      pr->print(' ');
-    }
-    pr->println();
-    pr->print(F("order: 0X"));
-    pr->println(ldir->order, HEX);
-    pr->print(F("attributes: 0X"));
-    pr->println(ldir->attributes, HEX);
-    pr->print(F("checksum: 0X"));
-    pr->println(ldir->checksum, HEX);
-  } else {
-    pr->println(F("Other"));
-  }
-  pr->println();
-  return true;
-}
-//------------------------------------------------------------------------------
-void FatFile::dmpFile(print_t* pr, uint32_t pos, size_t n) {
-  char text[17];
-  text[16] = 0;
-  if (n >= 0XFFF0) {
-    n = 0XFFF0;
-  }
-  if (!seekSet(pos)) {
-    return;
-  }
-  for (size_t i = 0; i <= n; i++) {
-    if ((i & 15) == 0) {
-      if (i) {
-        pr->write(' ');
-        pr->write(text);
-        if (i == n) {
-          break;
-        }
-      }
-      pr->write('\r');
-      pr->write('\n');
-      if (i >= n) {
-        break;
-      }
-      printHex(pr, 4, i);
-      pr->write(' ');
-    }
-    int16_t h = read();
-    if (h < 0) {
-      break;
-    }
-    pr->write(' ');
-    printHex(pr, 2, h);
-    text[i&15] = ' ' <= h && h < 0X7F ? h : '.';
-  }
-  pr->write('\r');
-  pr->write('\n');
-}
-//------------------------------------------------------------------------------
-bool FatPartition::dmpDirSector(print_t* pr, uint32_t sector) {
-  DirFat_t dir[16];
-  if (!cacheSafeRead(sector, reinterpret_cast<uint8_t*>(dir))) {
-    pr->println(F("dmpDir failed"));
-    return false;
-  }
-  for (uint8_t i = 0; i < 16; i++) {
-    if (!printFatDir(pr, dir + i)) {
-      return false;
-    }
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool FatPartition::dmpRootDir(print_t* pr, uint32_t n) {
-  uint32_t sector;
-  if (fatType() == 16) {
-    sector = rootDirStart();
-  } else if (fatType() == 32) {
-    sector = clusterStartSector(rootDirStart());
-  } else {
-    pr->println(F("dmpRootDir failed"));
-    return false;
-  }
-  return dmpDirSector(pr, sector + n);
-}
-//------------------------------------------------------------------------------
-void FatPartition::dmpSector(print_t* pr, uint32_t sector, uint8_t bits) {
-  uint8_t data[FatPartition::m_bytesPerSector];
-  if (!cacheSafeRead(sector, data)) {
-    pr->println(F("dmpSector failed"));
-    return;
-  }
-  for (uint16_t i = 0; i < m_bytesPerSector;) {
-    if (i%32 == 0) {
-      if (i) {
-        pr->println();
-      }
-      printHex(pr, i);
-    }
-    pr->write(' ');
-    if (bits == 32) {
-      printHex(pr, *reinterpret_cast<uint32_t*>(data + i));
-      i += 4;
-    } else if (bits == 16) {
-      printHex(pr, *reinterpret_cast<uint16_t*>(data + i));
-      i += 2;
-    } else {
-      printHex(pr, data[i++]);
-    }
-  }
-  pr->println();
-}
-//------------------------------------------------------------------------------
-void FatPartition::dmpFat(print_t* pr, uint32_t start, uint32_t count) {
-  uint16_t nf = fatType() == 16 ? 256 : fatType() == 32 ? 128 : 0;
-  if (nf == 0) {
-    pr->println(F("Invalid fatType"));
-    return;
-  }
-  pr->println(F("FAT:"));
-  uint32_t sector = m_fatStartSector + start;
-  uint32_t cluster = nf*start;
-  for (uint32_t i = 0; i < count; i++) {
-    uint8_t* pc = fatCachePrepare(sector + i, FsCache::CACHE_FOR_READ);
-    if (!pc) {
-      pr->println(F("cache read failed"));
-      return;
-    }
-    for (size_t k = 0; k < nf; k++) {
-      if (0 == cluster%8) {
-        if (k) {
-          pr->println();
-        }
-        printHex(pr, cluster);
-      }
-      cluster++;
-      pr->write(' ');
-      uint32_t v = fatType() == 32 ? getLe32(pc + 4*k) : getLe16(pc + 2*k);
-      printHex(pr, v);
-    }
-    pr->println();
-  }
-}
-#endif  // DOXYGEN_SHOULD_SKIP_THIS

lib/SdFat_NoArduino/src/FatLib/FatFile.cpp

@@ -1,1519 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "FatFile.cpp"
-#include "../common/DebugMacros.h"
-#include "FatLib.h"
-//------------------------------------------------------------------------------
-// Add a cluster to a file.
-bool FatFile::addCluster() {
-#if USE_FAT_FILE_FLAG_CONTIGUOUS
-  uint32_t cc = m_curCluster;
-  if (!m_vol->allocateCluster(m_curCluster, &m_curCluster)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (cc == 0) {
-    m_flags |= FILE_FLAG_CONTIGUOUS;
-  } else if (m_curCluster != (cc + 1)) {
-    m_flags &= ~FILE_FLAG_CONTIGUOUS;
-  }
-  m_flags |= FILE_FLAG_DIR_DIRTY;
-  return true;
-
- fail:
-  return false;
-#else  // USE_FAT_FILE_FLAG_CONTIGUOUS
-  m_flags |= FILE_FLAG_DIR_DIRTY;
-  return m_vol->allocateCluster(m_curCluster, &m_curCluster);
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-}
-//------------------------------------------------------------------------------
-// Add a cluster to a directory file and zero the cluster.
-// Return with first sector of cluster in the cache.
-bool FatFile::addDirCluster() {
-  uint32_t sector;
-  uint8_t* pc;
-
-  if (isRootFixed()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // max folder size
-  if (m_curPosition >= 512UL*4095) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!addCluster()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  sector = m_vol->clusterStartSector(m_curCluster);
-  for (uint8_t i = 0; i < m_vol->sectorsPerCluster(); i++) {
-    pc = m_vol->dataCachePrepare(sector + i, FsCache::CACHE_RESERVE_FOR_WRITE);
-    if (!pc) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    memset(pc, 0, m_vol->bytesPerSector());
-  }
-  // Set position to EOF to avoid inconsistent curCluster/curPosition.
-  m_curPosition += m_vol->bytesPerCluster();
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::attrib(uint8_t bits) {
-  if (!isFileOrSubDir() || (bits & FS_ATTRIB_USER_SETTABLE) != bits) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Don't allow read-only to be set if the file is open for write.
-  if ((bits & FS_ATTRIB_READ_ONLY) && isWritable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_attributes = (m_attributes & ~FS_ATTRIB_USER_SETTABLE) | bits;
-  // insure sync() will update dir entry
-  m_flags |= FILE_FLAG_DIR_DIRTY;
-  if (!sync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-// cache a file's directory entry
-// return pointer to cached entry or null for failure
-DirFat_t* FatFile::cacheDirEntry(uint8_t action) {
-  uint8_t* pc = m_vol->dataCachePrepare(m_dirSector, action);
-  DirFat_t* dir = reinterpret_cast<DirFat_t*>(pc);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return dir + (m_dirIndex & 0XF);
-
- fail:
-  return nullptr;
-}
-//------------------------------------------------------------------------------
-bool FatFile::close() {
-  bool rtn = sync();
-  m_attributes = FILE_ATTR_CLOSED;
-  m_flags = 0;
-  return rtn;
-}
-//------------------------------------------------------------------------------
-bool FatFile::contiguousRange(uint32_t* bgnSector, uint32_t* endSector) {
-  // error if no clusters
-  if (!isFile() || m_firstCluster == 0) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  for (uint32_t c = m_firstCluster; ; c++) {
-    uint32_t next;
-    int8_t fg = m_vol->fatGet(c, &next);
-    if (fg < 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // check for contiguous
-    if (fg == 0 || next != (c + 1)) {
-      // error if not end of chain
-      if (fg) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-#if USE_FAT_FILE_FLAG_CONTIGUOUS
-      m_flags |= FILE_FLAG_CONTIGUOUS;
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-      if (bgnSector) {
-        *bgnSector = m_vol->clusterStartSector(m_firstCluster);
-      }
-      if (endSector) {
-        *endSector = m_vol->clusterStartSector(c)
-                     + m_vol->sectorsPerCluster() - 1;
-      }
-      return true;
-    }
-  }
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::createContiguous(const char* path, uint32_t size) {
-  if (!open(FatVolume::cwv(), path, O_CREAT | O_EXCL | O_RDWR)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (preAllocate(size)) {
-    return true;
-  }
-  close();
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::createContiguous(FatFile* dirFile,
-                               const char* path, uint32_t size) {
-  if (!open(dirFile, path, O_CREAT | O_EXCL | O_RDWR)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (preAllocate(size)) {
-    return true;
-  }
-  close();
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::dirEntry(DirFat_t* dst) {
-  DirFat_t* dir;
-  // Make sure fields on device are correct.
-  if (!sync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // read entry
-  dir = cacheDirEntry(FsCache::CACHE_FOR_READ);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // copy to caller's struct
-  memcpy(dst, dir, sizeof(DirFat_t));
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-uint32_t FatFile::dirSize() {
-  int8_t fg;
-  if (!isDir()) {
-    return 0;
-  }
-  if (isRootFixed()) {
-    return FS_DIR_SIZE*m_vol->rootDirEntryCount();
-  }
-  uint16_t n = 0;
-  uint32_t c = isRoot32() ? m_vol->rootDirStart() : m_firstCluster;
-  do {
-    fg = m_vol->fatGet(c, &c);
-    if (fg < 0 || n > 4095) {
-      return 0;
-    }
-    n += m_vol->sectorsPerCluster();
-  } while (fg);
-  return 512UL*n;
-}
-//------------------------------------------------------------------------------
-int FatFile::fgets(char* str, int num, char* delim) {
-  char ch;
-  int n = 0;
-  int r = -1;
-  while ((n + 1) < num && (r = read(&ch, 1)) == 1) {
-    // delete CR
-    if (ch == '\r') {
-      continue;
-    }
-    str[n++] = ch;
-    if (!delim) {
-      if (ch == '\n') {
-        break;
-      }
-    } else {
-      if (strchr(delim, ch)) {
-        break;
-      }
-    }
-  }
-  if (r < 0) {
-    // read error
-    return -1;
-  }
-  str[n] = '\0';
-  return n;
-}
-//------------------------------------------------------------------------------
-void FatFile::fgetpos(fspos_t* pos) const {
-  pos->position = m_curPosition;
-  pos->cluster = m_curCluster;
-}
-//------------------------------------------------------------------------------
-uint32_t FatFile::firstSector() const {
-  return m_firstCluster ? m_vol->clusterStartSector(m_firstCluster) : 0;
-}
-//------------------------------------------------------------------------------
-void FatFile::fsetpos(const fspos_t* pos) {
-  m_curPosition = pos->position;
-  m_curCluster = pos->cluster;
-}
-//------------------------------------------------------------------------------
-bool FatFile::getAccessDate(uint16_t* pdate) {
-  DirFat_t dir;
-  if (!dirEntry(&dir)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  *pdate = getLe16(dir.accessDate);
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::getCreateDateTime(uint16_t* pdate, uint16_t* ptime) {
-  DirFat_t dir;
-  if (!dirEntry(&dir)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  *pdate = getLe16(dir.createDate);
-  *ptime = getLe16(dir.createTime);
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::getModifyDateTime(uint16_t* pdate, uint16_t* ptime) {
-  DirFat_t dir;
-  if (!dirEntry(&dir)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  *pdate = getLe16(dir.modifyDate);
-  *ptime = getLe16(dir.modifyTime);
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::isBusy() {
-  return m_vol->isBusy();
-}
-//------------------------------------------------------------------------------
-bool FatFile::mkdir(FatFile* parent, const char* path, bool pFlag) {
-  FatName_t fname;
-  FatFile tmpDir;
-
-  if (isOpen() || !parent->isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (isDirSeparator(*path)) {
-    while (isDirSeparator(*path)) {
-      path++;
-    }
-    if (!tmpDir.openRoot(parent->m_vol)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    parent = &tmpDir;
-  }
-  while (1) {
-    if (!parsePathName(path, &fname, &path)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (!*path) {
-      break;
-    }
-    if (!open(parent, &fname, O_RDONLY)) {
-      if (!pFlag || !mkdir(parent, &fname)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    tmpDir = *this;
-    parent = &tmpDir;
-    close();
-  }
-  return mkdir(parent, &fname);
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::mkdir(FatFile* parent, FatName_t* fname) {
-  uint32_t sector;
-  DirFat_t dot;
-  DirFat_t* dir;
-  uint8_t* pc;
-
-  if (!parent->isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // create a normal file
-  if (!open(parent, fname, O_CREAT | O_EXCL | O_RDWR)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // convert file to directory
-  m_flags = FILE_FLAG_READ;
-  m_attributes = FILE_ATTR_SUBDIR;
-
-  // allocate and zero first cluster
-  if (!addDirCluster()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_firstCluster = m_curCluster;
-  // Set to start of dir
-  rewind();
-  // force entry to device
-  if (!sync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // cache entry - should already be in cache due to sync() call
-  dir = cacheDirEntry(FsCache::CACHE_FOR_WRITE);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // change directory entry attribute
-  dir->attributes = FS_ATTRIB_DIRECTORY;
-
-  // make entry for '.'
-  memcpy(&dot, dir, sizeof(dot));
-  dot.name[0] = '.';
-  for (uint8_t i = 1; i < 11; i++) {
-    dot.name[i] = ' ';
-  }
-
-  // cache sector for '.'  and '..'
-  sector = m_vol->clusterStartSector(m_firstCluster);
-  pc = m_vol->dataCachePrepare(sector, FsCache::CACHE_FOR_WRITE);
-  dir = reinterpret_cast<DirFat_t*>(pc);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // copy '.' to sector
-  memcpy(&dir[0], &dot, sizeof(dot));
-  // make entry for '..'
-  dot.name[1] = '.';
-  setLe16(dot.firstClusterLow, parent->m_firstCluster & 0XFFFF);
-  setLe16(dot.firstClusterHigh, parent->m_firstCluster >> 16);
-  // copy '..' to sector
-  memcpy(&dir[1], &dot, sizeof(dot));
-  // write first sector
-  return m_vol->cacheSync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::open(const char* path, oflag_t oflag) {
-  return open(FatVolume::cwv(), path, oflag);
-}
-//------------------------------------------------------------------------------
-bool FatFile::open(FatVolume* vol, const char* path, oflag_t oflag) {
-  return vol && open(vol->vwd(), path, oflag);
-}
-//------------------------------------------------------------------------------
-bool FatFile::open(FatFile* dirFile, const char* path, oflag_t oflag) {
-  FatFile tmpDir;
-  FatName_t fname;
-
-  // error if already open
-  if (isOpen() || !dirFile->isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (isDirSeparator(*path)) {
-    while (isDirSeparator(*path)) {
-      path++;
-    }
-    if (*path == 0) {
-      return openRoot(dirFile->m_vol);
-    }
-    if (!tmpDir.openRoot(dirFile->m_vol)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    dirFile = &tmpDir;
-  }
-  while (1) {
-    if (!parsePathName(path, &fname, &path)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (*path == 0) {
-      break;
-    }
-    if (!open(dirFile, &fname, O_RDONLY)) {
-      DBG_WARN_MACRO;
-      goto fail;
-    }
-    tmpDir = *this;
-    dirFile = &tmpDir;
-    close();
-  }
-  return open(dirFile, &fname, oflag);
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::open(uint16_t index, oflag_t oflag) {
-  FatVolume* vol = FatVolume::cwv();
-  return vol ? open(vol->vwd(), index, oflag) : false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::open(FatFile* dirFile, uint16_t index, oflag_t oflag) {
-  if (index) {
-    // Find start of LFN.
-    DirLfn_t* ldir;
-    uint8_t n = index < 20 ? index : 20;
-    for (uint8_t i = 1; i <= n; i++) {
-      ldir = reinterpret_cast<DirLfn_t*>(dirFile->cacheDir(index - i));
-      if (!ldir) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      if (ldir->attributes != FAT_ATTRIB_LONG_NAME) {
-        break;
-      }
-      if (ldir->order & FAT_ORDER_LAST_LONG_ENTRY) {
-        if (!dirFile->seekSet(32UL*(index - i))) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        break;
-      }
-    }
-  } else {
-    dirFile->rewind();
-  }
-  if (!openNext(dirFile, oflag)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (dirIndex() != index) {
-    close();
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-// open a cached directory entry.
-bool FatFile::openCachedEntry(FatFile* dirFile, uint16_t dirIndex,
-                              oflag_t oflag, uint8_t lfnOrd) {
-  uint32_t firstCluster;
-  memset(this, 0, sizeof(FatFile));
-  // location of entry in cache
-  m_vol = dirFile->m_vol;
-  m_dirIndex = dirIndex;
-  m_dirCluster = dirFile->m_firstCluster;
-  DirFat_t* dir = reinterpret_cast<DirFat_t*>(m_vol->cacheAddress());
-  dir += 0XF & dirIndex;
-
-  // Must be file or subdirectory.
-  if (!isFatFileOrSubdir(dir)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_attributes = dir->attributes & FS_ATTRIB_COPY;
-  if (isFatFile(dir)) {
-    m_attributes |= FILE_ATTR_FILE;
-  }
-  m_lfnOrd = lfnOrd;
-
-  switch (oflag & O_ACCMODE) {
-    case O_RDONLY:
-      if (oflag & O_TRUNC) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      m_flags = FILE_FLAG_READ;
-      break;
-
-    case O_RDWR:
-      m_flags = FILE_FLAG_READ | FILE_FLAG_WRITE;
-      break;
-
-    case O_WRONLY:
-      m_flags = FILE_FLAG_WRITE;
-      break;
-
-    default:
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-
-  if (m_flags & FILE_FLAG_WRITE) {
-    if (isSubDir() || isReadOnly()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    m_attributes |= FS_ATTRIB_ARCHIVE;
-  }
-  m_flags |= (oflag & O_APPEND ? FILE_FLAG_APPEND : 0);
-
-  m_dirSector = m_vol->cacheSectorNumber();
-
-  // copy first cluster number for directory fields
-  firstCluster = ((uint32_t)getLe16(dir->firstClusterHigh) << 16)
-                 | getLe16(dir->firstClusterLow);
-
-  if (oflag & O_TRUNC) {
-    if (firstCluster && !m_vol->freeChain(firstCluster)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // need to update directory entry
-    m_flags |= FILE_FLAG_DIR_DIRTY;
-  } else {
-    m_firstCluster = firstCluster;
-    m_fileSize = getLe32(dir->fileSize);
-  }
-  if ((oflag & O_AT_END) && !seekSet(m_fileSize)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  m_attributes = FILE_ATTR_CLOSED;
-  m_flags = 0;
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::openCluster(FatFile* file) {
-  if (file->m_dirCluster == 0) {
-    return openRoot(file->m_vol);
-  }
-  memset(this, 0, sizeof(FatFile));
-  m_attributes = FILE_ATTR_SUBDIR;
-  m_flags = FILE_FLAG_READ;
-  m_vol = file->m_vol;
-  m_firstCluster = file->m_dirCluster;
-  return true;
-}
-//------------------------------------------------------------------------------
-bool FatFile::openCwd() {
-  if (isOpen() || !FatVolume::cwv()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  *this = *FatVolume::cwv()->vwd();
-  rewind();
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::openNext(FatFile* dirFile, oflag_t oflag) {
-  uint8_t checksum = 0;
-  DirLfn_t* ldir;
-  uint8_t lfnOrd = 0;
-  uint16_t index;
-
-  // Check for not open and valid directory..
-  if (isOpen() || !dirFile->isDir() || (dirFile->curPosition() & 0X1F)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  while (1) {
-    // read entry into cache
-    index = dirFile->curPosition()/FS_DIR_SIZE;
-    DirFat_t* dir = dirFile->readDirCache();
-    if (!dir) {
-      if (dirFile->getError()) {
-        DBG_FAIL_MACRO;
-      }
-      goto fail;
-    }
-    // done if last entry
-    if (dir->name[0] == FAT_NAME_FREE) {
-      goto fail;
-    }
-    // skip empty slot or '.' or '..'
-    if (dir->name[0] == '.' || dir->name[0] == FAT_NAME_DELETED) {
-      lfnOrd = 0;
-    } else if (isFatFileOrSubdir(dir)) {
-      if (lfnOrd && checksum != lfnChecksum(dir->name)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      if (!openCachedEntry(dirFile, index, oflag, lfnOrd)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      return true;
-    } else if (isFatLongName(dir)) {
-      ldir = reinterpret_cast<DirLfn_t*>(dir);
-      if (ldir->order & FAT_ORDER_LAST_LONG_ENTRY) {
-        lfnOrd = ldir->order & 0X1F;
-        checksum = ldir->checksum;
-      }
-    } else {
-      lfnOrd = 0;
-    }
-  }
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::openRoot(FatVolume* vol) {
-  // error if file is already open
-  if (isOpen()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  memset(this, 0, sizeof(FatFile));
-
-  m_vol = vol;
-  switch (vol->fatType()) {
-#if FAT12_SUPPORT
-  case 12:
-#endif  // FAT12_SUPPORT
-  case 16:
-    m_attributes = FILE_ATTR_ROOT_FIXED;
-    break;
-
-  case 32:
-    m_attributes = FILE_ATTR_ROOT32;
-    break;
-
-  default:
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // read only
-  m_flags = FILE_FLAG_READ;
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-int FatFile::peek() {
-  uint32_t curPosition = m_curPosition;
-  uint32_t curCluster = m_curCluster;
-  int c = read();
-  m_curPosition = curPosition;
-  m_curCluster = curCluster;
-  return c;
-}
-//------------------------------------------------------------------------------
-bool FatFile::preAllocate(uint32_t length) {
-  uint32_t need;
-  if (!length || !isWritable() || m_firstCluster) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  need = 1 + ((length - 1) >> m_vol->bytesPerClusterShift());
-  // allocate clusters
-  if (!m_vol->allocContiguous(need, &m_firstCluster)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_fileSize = length;
-
-#if USE_FAT_FILE_FLAG_CONTIGUOUS
-  // Mark contiguous and insure sync() will update dir entry
-  m_flags |= FILE_FLAG_PREALLOCATE | FILE_FLAG_CONTIGUOUS | FILE_FLAG_DIR_DIRTY;
-#else  // USE_FAT_FILE_FLAG_CONTIGUOUS
-  // insure sync() will update dir entry
-  m_flags |= FILE_FLAG_DIR_DIRTY;
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-  return sync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-int FatFile::read(void* buf, size_t nbyte) {
-  int8_t fg;
-  uint8_t sectorOfCluster = 0;
-  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
-  uint16_t offset;
-  size_t toRead;
-  uint32_t sector;  // raw device sector number
-  uint8_t* pc;
-  // error if not open for read
-  if (!isReadable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-
-  if (isFile()) {
-    uint32_t tmp32 = m_fileSize - m_curPosition;
-    if (nbyte >= tmp32) {
-      nbyte = tmp32;
-    }
-  } else if (isRootFixed()) {
-    uint16_t tmp16 =
-      FS_DIR_SIZE*m_vol->m_rootDirEntryCount - (uint16_t)m_curPosition;
-    if (nbyte > tmp16) {
-      nbyte = tmp16;
-    }
-  }
-  toRead = nbyte;
-  while (toRead) {
-    size_t n;
-    offset = m_curPosition & m_vol->sectorMask();  // offset in sector
-    if (isRootFixed()) {
-      sector = m_vol->rootDirStart()
-               + (m_curPosition >> m_vol->bytesPerSectorShift());
-    } else {
-      sectorOfCluster = m_vol->sectorOfCluster(m_curPosition);
-      if (offset == 0 && sectorOfCluster == 0) {
-        // start of new cluster
-        if (m_curPosition == 0) {
-          // use first cluster in file
-          m_curCluster = isRoot32() ? m_vol->rootDirStart() : m_firstCluster;
-#if USE_FAT_FILE_FLAG_CONTIGUOUS
-        } else if (isFile() && isContiguous()) {
-          m_curCluster++;
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-        } else {
-          // get next cluster from FAT
-          fg = m_vol->fatGet(m_curCluster, &m_curCluster);
-          if (fg < 0) {
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-          if (fg == 0) {
-            if (isDir()) {
-              break;
-            }
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-        }
-      }
-      sector = m_vol->clusterStartSector(m_curCluster) + sectorOfCluster;
-    }
-    if (offset != 0 || toRead < m_vol->bytesPerSector()
-        || sector == m_vol->cacheSectorNumber()) {
-      // amount to be read from current sector
-      n = m_vol->bytesPerSector() - offset;
-      if (n > toRead) {
-        n = toRead;
-      }
-      // read sector to cache and copy data to caller
-      pc = m_vol->dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
-      if (!pc) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      uint8_t* src = pc + offset;
-      memcpy(dst, src, n);
-#if USE_MULTI_SECTOR_IO
-    } else if (toRead >= 2*m_vol->bytesPerSector()) {
-      uint32_t ns = toRead >> m_vol->bytesPerSectorShift();
-      if (!isRootFixed()) {
-        uint32_t mb = m_vol->sectorsPerCluster() - sectorOfCluster;
-        if (mb < ns) {
-          ns = mb;
-        }
-      }
-      n = ns << m_vol->bytesPerSectorShift();
-      if (!m_vol->cacheSafeRead(sector, dst, ns)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-#endif  // USE_MULTI_SECTOR_IO
-    } else {
-      // read single sector
-      n = m_vol->bytesPerSector();
-      if (!m_vol->cacheSafeRead(sector, dst)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    dst += n;
-    m_curPosition += n;
-    toRead -= n;
-  }
-  return nbyte - toRead;
-
- fail:
-  m_error |= READ_ERROR;
-  return -1;
-}
-//------------------------------------------------------------------------------
-int8_t FatFile::readDir(DirFat_t* dir) {
-  int16_t n;
-  // if not a directory file or miss-positioned return an error
-  if (!isDir() || (0X1F & m_curPosition)) {
-    return -1;
-  }
-
-  while (1) {
-    n = read(dir, sizeof(DirFat_t));
-    if (n != sizeof(DirFat_t)) {
-      return n == 0 ? 0 : -1;
-    }
-    // last entry if FAT_NAME_FREE
-    if (dir->name[0] == FAT_NAME_FREE) {
-      return 0;
-    }
-    // skip empty entries and entry for .  and ..
-    if (dir->name[0] == FAT_NAME_DELETED || dir->name[0] == '.') {
-      continue;
-    }
-    // return if normal file or subdirectory
-    if (isFatFileOrSubdir(dir)) {
-      return n;
-    }
-  }
-}
-//------------------------------------------------------------------------------
-// Read next directory entry into the cache.
-// Assumes file is correctly positioned.
-DirFat_t* FatFile::readDirCache(bool skipReadOk) {
-  DBG_HALT_IF(m_curPosition & 0X1F);
-  uint8_t i = (m_curPosition >> 5) & 0XF;
-
-  if (i == 0 || !skipReadOk) {
-    int8_t n = read(&n, 1);
-    if  (n != 1) {
-      if (n != 0) {
-        DBG_FAIL_MACRO;
-      }
-      goto fail;
-    }
-    m_curPosition += FS_DIR_SIZE - 1;
-  } else {
-    m_curPosition += FS_DIR_SIZE;
-  }
-  // return pointer to entry
-  return reinterpret_cast<DirFat_t*>(m_vol->cacheAddress()) + i;
-
- fail:
-  return nullptr;
-}
-//------------------------------------------------------------------------------
-bool FatFile::remove(const char* path) {
-  FatFile file;
-  if (!file.open(this, path, O_WRONLY)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return file.remove();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::rename(const char* newPath) {
-  return rename(m_vol->vwd(), newPath);
-}
-//------------------------------------------------------------------------------
-bool FatFile::rename(FatFile* dirFile, const char* newPath) {
-  DirFat_t entry;
-  uint32_t dirCluster = 0;
-  FatFile file;
-  FatFile oldFile;
-  uint8_t* pc;
-  DirFat_t* dir;
-
-  // Must be an open file or subdirectory.
-  if (!(isFile() || isSubDir())) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Can't rename LFN in 8.3 mode.
-  if (!USE_LONG_FILE_NAMES && isLFN()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Can't move file to new volume.
-  if (m_vol != dirFile->m_vol) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // sync() and cache directory entry
-  sync();
-  oldFile = *this;
-  dir = cacheDirEntry(FsCache::CACHE_FOR_READ);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // save directory entry
-  memcpy(&entry, dir, sizeof(entry));
-  // make directory entry for new path
-  if (isFile()) {
-    if (!file.open(dirFile, newPath, O_CREAT | O_EXCL | O_WRONLY)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  } else {
-    // don't create missing path prefix components
-    if (!file.mkdir(dirFile, newPath, false)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // save cluster containing new dot dot
-    dirCluster = file.m_firstCluster;
-  }
-  // change to new directory entry
-
-  m_dirSector = file.m_dirSector;
-  m_dirIndex = file.m_dirIndex;
-  m_lfnOrd = file.m_lfnOrd;
-  m_dirCluster = file.m_dirCluster;
-  // mark closed to avoid possible destructor close call
-  file.m_attributes = FILE_ATTR_CLOSED;
-  file.m_flags = 0;
-
-  // cache new directory entry
-  dir = cacheDirEntry(FsCache::CACHE_FOR_WRITE);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // copy all but name and name flags to new directory entry
-  memcpy(&dir->createTimeMs, &entry.createTimeMs,
-         sizeof(entry) - sizeof(dir->name) - 2);
-  dir->attributes = entry.attributes;
-
-  // update dot dot if directory
-  if (dirCluster) {
-    // get new dot dot
-    uint32_t sector = m_vol->clusterStartSector(dirCluster);
-    pc = m_vol->dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
-    dir = reinterpret_cast<DirFat_t*>(pc);
-    if (!dir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    memcpy(&entry, &dir[1], sizeof(entry));
-
-    // free unused cluster
-    if (!m_vol->freeChain(dirCluster)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // store new dot dot
-    sector = m_vol->clusterStartSector(m_firstCluster);
-    uint8_t* pc = m_vol->dataCachePrepare(sector, FsCache::CACHE_FOR_WRITE);
-    dir = reinterpret_cast<DirFat_t*>(pc);
-    if (!dir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    memcpy(&dir[1], &entry, sizeof(entry));
-  }
-  // Remove old directory entry;
-  oldFile.m_firstCluster = 0;
-  oldFile.m_flags = FILE_FLAG_WRITE;
-  oldFile.m_attributes = FILE_ATTR_FILE;
-  if (!oldFile.remove()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return m_vol->cacheSync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::rmdir() {
-  // must be open subdirectory
-  if (!isSubDir() || (!USE_LONG_FILE_NAMES && isLFN())) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  rewind();
-
-  // make sure directory is empty
-  while (1) {
-    DirFat_t* dir = readDirCache(true);
-    if (!dir) {
-      // EOF if no error.
-      if (!getError()) {
-        break;
-      }
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // done if past last used entry
-    if (dir->name[0] == FAT_NAME_FREE) {
-      break;
-    }
-    // skip empty slot, '.' or '..'
-    if (dir->name[0] == FAT_NAME_DELETED || dir->name[0] == '.') {
-      continue;
-    }
-    // error not empty
-    if (isFatFileOrSubdir(dir)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  // convert empty directory to normal file for remove
-  m_attributes = FILE_ATTR_FILE;
-  m_flags |= FILE_FLAG_WRITE;
-  return remove();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::rmRfStar() {
-  uint16_t index;
-  FatFile f;
-  if (!isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  rewind();
-  while (1) {
-    // remember position
-    index = m_curPosition/FS_DIR_SIZE;
-
-    DirFat_t* dir = readDirCache();
-    if (!dir) {
-      // At EOF if no error.
-      if (!getError()) {
-        break;
-      }
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // done if past last entry
-    if (dir->name[0] == FAT_NAME_FREE) {
-      break;
-    }
-
-    // skip empty slot or '.' or '..'
-    if (dir->name[0] == FAT_NAME_DELETED || dir->name[0] == '.') {
-      continue;
-    }
-
-    // skip if part of long file name or volume label in root
-    if (!isFatFileOrSubdir(dir)) {
-      continue;
-    }
-
-    if (!f.open(this, index, O_RDONLY)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (f.isSubDir()) {
-      // recursively delete
-      if (!f.rmRfStar()) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    } else {
-      // ignore read-only
-      f.m_flags |= FILE_FLAG_WRITE;
-      if (!f.remove()) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    // position to next entry if required
-    if (m_curPosition != (32UL*(index + 1))) {
-      if (!seekSet(32UL*(index + 1))) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-  }
-  // don't try to delete root
-  if (!isRoot()) {
-    if (!rmdir()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::seekSet(uint32_t pos) {
-  uint32_t nCur;
-  uint32_t nNew;
-  uint32_t tmp = m_curCluster;
-  // error if file not open
-  if (!isOpen()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Optimize O_APPEND writes.
-  if (pos == m_curPosition) {
-    return true;
-  }
-  if (pos == 0) {
-    // set position to start of file
-    m_curCluster = 0;
-    goto done;
-  }
-  if (isFile()) {
-    if (pos > m_fileSize) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  } else if (isRootFixed()) {
-    if (pos <= FS_DIR_SIZE*m_vol->rootDirEntryCount()) {
-      goto done;
-    }
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // calculate cluster index for new position
-  nNew = (pos - 1) >> (m_vol->bytesPerClusterShift());
-#if USE_FAT_FILE_FLAG_CONTIGUOUS
-  if (isContiguous()) {
-    m_curCluster = m_firstCluster + nNew;
-    goto done;
-  }
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-  // calculate cluster index for current position
-  nCur = (m_curPosition - 1) >> (m_vol->bytesPerClusterShift());
-
-  if (nNew < nCur || m_curPosition == 0) {
-    // must follow chain from first cluster
-    m_curCluster = isRoot32() ? m_vol->rootDirStart() : m_firstCluster;
-  } else {
-    // advance from curPosition
-    nNew -= nCur;
-  }
-  while (nNew--) {
-    if (m_vol->fatGet(m_curCluster, &m_curCluster) <= 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-
- done:
-  m_curPosition = pos;
-  m_flags &= ~FILE_FLAG_PREALLOCATE;
-  return true;
-
- fail:
-  m_curCluster = tmp;
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::sync() {
-  uint16_t date, time;
-  uint8_t ms10;
-  if (!isOpen()) {
-    return true;
-  }
-  if (m_flags & FILE_FLAG_DIR_DIRTY) {
-    DirFat_t* dir = cacheDirEntry(FsCache::CACHE_FOR_WRITE);
-    // check for deleted by another open file object
-    if (!dir || dir->name[0] == FAT_NAME_DELETED) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    dir->attributes = m_attributes & FS_ATTRIB_COPY;
-    // do not set filesize for dir files
-    if (isFile()) {
-      setLe32(dir->fileSize, m_fileSize);
-    }
-    // update first cluster fields
-    setLe16(dir->firstClusterLow, m_firstCluster & 0XFFFF);
-    setLe16(dir->firstClusterHigh, m_firstCluster >> 16);
-
-    // set modify time if user supplied a callback date/time function
-    if (FsDateTime::callback) {
-      FsDateTime::callback(&date, &time, &ms10);
-      setLe16(dir->modifyDate, date);
-      setLe16(dir->accessDate, date);
-      setLe16(dir->modifyTime, time);
-    }
-    // clear directory dirty
-    m_flags &= ~FILE_FLAG_DIR_DIRTY;
-  }
-  if (m_vol->cacheSync()) {
-    return true;
-  }
-  DBG_FAIL_MACRO;
-
- fail:
-  m_error |= WRITE_ERROR;
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
-                   uint8_t day, uint8_t hour, uint8_t minute, uint8_t second) {
-  uint16_t dirDate;
-  uint16_t dirTime;
-  DirFat_t* dir;
-
-  if (!isFile()
-      || year < 1980
-      || year > 2107
-      || month < 1
-      || month > 12
-      || day < 1
-      || day > 31
-      || hour > 23
-      || minute > 59
-      || second > 59) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // update directory entry
-  if (!sync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  dir = cacheDirEntry(FsCache::CACHE_FOR_WRITE);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  dirDate = FS_DATE(year, month, day);
-  dirTime = FS_TIME(hour, minute, second);
-  if (flags & T_ACCESS) {
-    setLe16(dir->accessDate, dirDate);
-  }
-  if (flags & T_CREATE) {
-    setLe16(dir->createDate, dirDate);
-    setLe16(dir->createTime, dirTime);
-    // units of 10 ms
-    dir->createTimeMs = second & 1 ? 100 : 0;
-  }
-  if (flags & T_WRITE) {
-    setLe16(dir->modifyDate, dirDate);
-    setLe16(dir->modifyTime, dirTime);
-  }
-  return m_vol->cacheSync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::truncate() {
-  uint32_t toFree;
-  // error if not a normal file or read-only
-  if (!isWritable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (m_firstCluster == 0) {
-      return true;
-  }
-  if (m_curCluster) {
-    toFree = 0;
-    int8_t fg = m_vol->fatGet(m_curCluster, &toFree);
-    if (fg < 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (fg) {
-      // current cluster is end of chain
-      if (!m_vol->fatPutEOC(m_curCluster)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-  } else {
-    toFree = m_firstCluster;
-    m_firstCluster = 0;
-  }
-  if (toFree) {
-    if (!m_vol->freeChain(toFree)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  m_fileSize = m_curPosition;
-
-  // need to update directory entry
-  m_flags |= FILE_FLAG_DIR_DIRTY;
-  return sync();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::write(const void* buf, size_t nbyte) {
-  // convert void* to uint8_t*  -  must be before goto statements
-  const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);
-  uint8_t* pc;
-  uint8_t cacheOption;
-  // number of bytes left to write  -  must be before goto statements
-  size_t nToWrite = nbyte;
-  size_t n;
-  // error if not a normal file or is read-only
-  if (!isWritable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // seek to end of file if append flag
-  if ((m_flags & FILE_FLAG_APPEND)) {
-    if (!seekSet(m_fileSize)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  // Don't exceed max fileSize.
-  if (nbyte > (0XFFFFFFFF - m_curPosition)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  while (nToWrite) {
-    uint8_t sectorOfCluster = m_vol->sectorOfCluster(m_curPosition);
-    uint16_t sectorOffset = m_curPosition & m_vol->sectorMask();
-    if (sectorOfCluster == 0 && sectorOffset == 0) {
-      // start of new cluster
-      if (m_curCluster != 0) {
-#if USE_FAT_FILE_FLAG_CONTIGUOUS
-        int8_t fg;
-        if (isContiguous() && m_fileSize > m_curPosition) {
-          m_curCluster++;
-          fg = 1;
-        } else {
-          fg = m_vol->fatGet(m_curCluster, &m_curCluster);
-          if (fg < 0) {
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-        }
-#else  // USE_FAT_FILE_FLAG_CONTIGUOUS
-        int8_t fg = m_vol->fatGet(m_curCluster, &m_curCluster);
-        if (fg < 0) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-        if (fg == 0) {
-          // add cluster if at end of chain
-          if (!addCluster()) {
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-        }
-      } else {
-        if (m_firstCluster == 0) {
-          // allocate first cluster of file
-          if (!addCluster()) {
-            DBG_FAIL_MACRO;
-            goto fail;
-          }
-          m_firstCluster = m_curCluster;
-        } else {
-          m_curCluster = m_firstCluster;
-        }
-      }
-    }
-    // sector for data write
-    uint32_t sector = m_vol->clusterStartSector(m_curCluster)
-                      + sectorOfCluster;
-
-    if (sectorOffset != 0 || nToWrite < m_vol->bytesPerSector()) {
-      // partial sector - must use cache
-      // max space in sector
-      n = m_vol->bytesPerSector() - sectorOffset;
-      // lesser of space and amount to write
-      if (n > nToWrite) {
-        n = nToWrite;
-      }
-
-      if (sectorOffset == 0 &&
-         (m_curPosition >= m_fileSize || m_flags & FILE_FLAG_PREALLOCATE)) {
-        // start of new sector don't need to read into cache
-        cacheOption = FsCache::CACHE_RESERVE_FOR_WRITE;
-      } else {
-        // rewrite part of sector
-        cacheOption = FsCache::CACHE_FOR_WRITE;
-      }
-      pc = m_vol->dataCachePrepare(sector, cacheOption);
-      if (!pc) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      uint8_t* dst = pc + sectorOffset;
-      memcpy(dst, src, n);
-      if (m_vol->bytesPerSector() == (n + sectorOffset)) {
-        // Force write if sector is full - improves large writes.
-        if (!m_vol->cacheSyncData()) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-      }
-#if USE_MULTI_SECTOR_IO
-    } else if (nToWrite >= 2*m_vol->bytesPerSector()) {
-      // use multiple sector write command
-      uint32_t maxSectors = m_vol->sectorsPerCluster() - sectorOfCluster;
-      uint32_t nSector = nToWrite >> m_vol->bytesPerSectorShift();
-      if (nSector > maxSectors) {
-        nSector = maxSectors;
-      }
-      n = nSector << m_vol->bytesPerSectorShift();
-      if (!m_vol->cacheSafeWrite(sector, src, nSector)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-#endif  // USE_MULTI_SECTOR_IO
-    } else {
-      // use single sector write command
-      n = m_vol->bytesPerSector();
-      if (!m_vol->cacheSafeWrite(sector, src)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    m_curPosition += n;
-    src += n;
-    nToWrite -= n;
-  }
-  if (m_curPosition > m_fileSize) {
-    // update fileSize and insure sync will update dir entry
-    m_fileSize = m_curPosition;
-    m_flags |= FILE_FLAG_DIR_DIRTY;
-  } else if (FsDateTime::callback) {
-    // insure sync will update modified date and time
-    m_flags |= FILE_FLAG_DIR_DIRTY;
-  }
-  return nbyte;
-
- fail:
-  // return for write error
-  m_error |= WRITE_ERROR;
-  return 0;
-}

lib/SdFat_NoArduino/src/FatLib/FatFile.h

@@ -1,1086 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FatFile_h
-#define FatFile_h
-/**
- * \file
- * \brief FatFile class
- */
-#include <string.h>
-#include <stddef.h>
-#include <limits.h>
-#include "../common/FmtNumber.h"
-#include "../common/FsApiConstants.h"
-#include "../common/FsDateTime.h"
-#include "../common/FsName.h"
-#include "FatPartition.h"
-class FatVolume;
-//------------------------------------------------------------------------------
-// Stuff to store strings in AVR flash.
-#ifdef __AVR__
-#include <avr/pgmspace.h>
-#else  // __AVR__
-#ifndef PSTR
-/** store literal string in flash for ARM */
-#define PSTR(x) (x)
-#endif  // PSTR
-#ifndef pgm_read_byte
-/** read 8-bits from flash for ARM */
-#define pgm_read_byte(addr) (*(const unsigned char*)(addr))
-#endif  // pgm_read_byte
-#ifndef pgm_read_word
-/** read 16-bits from flash for ARM */
-#define pgm_read_word(addr) (*(const uint16_t*)(addr))
-#endif  // pgm_read_word
-#ifndef PROGMEM
-/** store in flash for ARM */
-#define PROGMEM
-#endif  // PROGMEM
-#endif  // __AVR__
-//------------------------------------------------------------------------------
-/**
- * \struct FatPos_t
- * \brief Internal type for file position - do not use in user apps.
- */
-struct FatPos_t {
-  /** stream position */
-  uint32_t position;
-  /** cluster for position */
-  uint32_t cluster;
-};
-//------------------------------------------------------------------------------
-/** Expression for path name separator. */
-#define isDirSeparator(c) ((c) == '/')
-//------------------------------------------------------------------------------
-/**
- * \class FatLfn_t
- * \brief Internal type for Long File Name - do not use in user apps.
- */
-
-class FatLfn_t : public FsName {
- public:
-  /** UTF-16 length of Long File Name */
-  size_t len;
-  /** Position for sequence number. */
-  uint8_t seqPos;
-  /** Flags for base and extension character case and LFN. */
-  uint8_t flags;
-  /** Short File Name */
-  uint8_t sfn[11];
-};
-/**
- * \class FatSfn_t
- * \brief Internal type for Short 8.3 File Name - do not use in user apps.
- */
-class FatSfn_t {
- public:
-  /** Flags for base and extension character case and LFN. */
-  uint8_t flags;
-  /** Short File Name */
-  uint8_t sfn[11];
-};
-
-#if USE_LONG_FILE_NAMES
-/** Internal class for file names */
-typedef FatLfn_t FatName_t;
-#else  // USE_LONG_FILE_NAMES
-/** Internal class for file names */
-typedef FatSfn_t FatName_t;
-#endif  // USE_LONG_FILE_NAMES
-
-/** Derived from a LFN with loss or conversion of characters. */
-const uint8_t FNAME_FLAG_LOST_CHARS = 0X01;
-/** Base-name or extension has mixed case. */
-const uint8_t FNAME_FLAG_MIXED_CASE = 0X02;
-/** LFN entries are required for file name. */
-const uint8_t FNAME_FLAG_NEED_LFN =
-  FNAME_FLAG_LOST_CHARS | FNAME_FLAG_MIXED_CASE;
-/** Filename base-name is all lower case */
-const uint8_t FNAME_FLAG_LC_BASE = FAT_CASE_LC_BASE;
-/** Filename extension is all lower case. */
-const uint8_t FNAME_FLAG_LC_EXT = FAT_CASE_LC_EXT;
-#if FNAME_FLAG_NEED_LFN & (FAT_CASE_LC_BASE || FAT_CASE_LC_EXT)
-#error FNAME_FLAG_NEED_LFN & (FAT_CASE_LC_BASE || FAT_CASE_LC_EXT)
-#endif  // FNAME_FLAG_NEED_LFN & (FAT_CASE_LC_BASE || FAT_CASE_LC_EXT)
-//==============================================================================
-/**
- * \class FatFile
- * \brief Basic file class.
- */
-class FatFile {
- public:
-  /** Create an instance. */
-  FatFile() {}
-  /**  Create a file object and open it in the current working directory.
-   *
-   * \param[in] path A path for a file to be opened.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
-   * OR of open flags. see FatFile::open(FatFile*, const char*, uint8_t).
-   */
-  FatFile(const char* path, oflag_t oflag) {
-    open(path, oflag);
-  }
-#if DESTRUCTOR_CLOSES_FILE
-  /** Destructor */
-  ~FatFile() {
-    if (isOpen()) {
-      close();
-    }
-  }
-#endif  // DESTRUCTOR_CLOSES_FILE
-  /** The parenthesis operator.
-   *
-   * \return true if a file is open.
-   */
-  operator bool() const {return isOpen();}
-  /**
-   * \return user settable file attributes for success else -1.
-   */
-  int attrib() {
-    return isFileOrSubDir() ? m_attributes & FS_ATTRIB_USER_SETTABLE : -1;
-  }
-  /** Set file attributes
-   *
-   * \param[in] bits bit-wise or of selected attributes: FS_ATTRIB_READ_ONLY,
-   *            FS_ATTRIB_HIDDEN, FS_ATTRIB_SYSTEM, FS_ATTRIB_ARCHIVE.
-   *
-   * \note attrib() will fail for set read-only if the file is open for write.
-   * \return true for success or false for failure.
-   */
-  bool attrib(uint8_t bits);
-  /** \return The number of bytes available from the current position
-   * to EOF for normal files.  INT_MAX is returned for very large files.
-   *
-   * available32() is recomended for very large files.
-   *
-   * Zero is returned for directory files.
-   *
-   */
-  int available() const {
-    uint32_t n = available32();
-    return n > INT_MAX ? INT_MAX : n;
-  }
-  /** \return The number of bytes available from the current position
-   * to EOF for normal files.  Zero is returned for directory files.
-   */
-  uint32_t available32() const {
-    return isFile() ? fileSize() - curPosition() : 0;
-  }
-  /** Clear all error bits. */
-  void clearError() {
-    m_error = 0;
-  }
-  /** Set writeError to zero */
-  void clearWriteError() {
-    m_error &= ~WRITE_ERROR;
-  }
-  /** Close a file and force cached data and directory information
-   *  to be written to the storage device.
-   *
-   * \return true for success or false for failure.
-   */
-  bool close();
-  /** Check for contiguous file and return its raw sector range.
-   *
-   * \param[out] bgnSector the first sector address for the file.
-   * \param[out] endSector the last sector address for the file.
-   *
-   * Set the contiguous flag if the file is contiguous.
-   * The parameters may be nullptr to only set the flag.
-   * \return true for success or false for failure.
-   */
-  bool contiguousRange(uint32_t* bgnSector, uint32_t* endSector);
-  /** Create and open a new contiguous file of a specified size.
-   *
-   * \param[in] dirFile The directory where the file will be created.
-   * \param[in] path A path with a valid file name.
-   * \param[in] size The desired file size.
-   *
-   * \return true for success or false for failure.
-   */
-  bool createContiguous(FatFile* dirFile,
-                        const char* path, uint32_t size);
-  /** Create and open a new contiguous file of a specified size.
-   *
-   * \param[in] path A path with a valid file name.
-   * \param[in] size The desired file size.
-   *
-   * \return true for success or false for failure.
-   */
-  bool createContiguous(const char* path, uint32_t size);
-  /** \return The current cluster number for a file or directory. */
-  uint32_t curCluster() const {return m_curCluster;}
-
-  /** \return The current position for a file or directory. */
-  uint32_t curPosition() const {return m_curPosition;}
-  /** Return a file's directory entry.
-   *
-   * \param[out] dir Location for return of the file's directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool dirEntry(DirFat_t* dir);
-  /** \return Directory entry index. */
-  uint16_t dirIndex() const {return m_dirIndex;}
-  /** \return The number of bytes allocated to a directory or zero
-   *         if an error occurs.
-   */
-  uint32_t dirSize();
-  /** Dump file in Hex
-   * \param[in] pr Print stream for list.
-   * \param[in] pos Start position in file.
-   * \param[in] n number of locations to dump.
-   */
-  void dmpFile(print_t* pr, uint32_t pos, size_t n);
-  /** Test for the existence of a file in a directory
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * The calling instance must be an open directory file.
-   *
-   * dirFile.exists("TOFIND.TXT") searches for "TOFIND.TXT" in the directory
-   * dirFile.
-   *
-   * \return True if the file exists.
-   */
-  bool exists(const char* path) {
-    FatFile file;
-    return file.open(this, path, O_RDONLY);
-  }
-  /** get position for streams
-   * \param[out] pos struct to receive position
-   */
-  void fgetpos(fspos_t* pos) const;
-  /**
-   * Get a string from a file.
-   *
-   * fgets() reads bytes from a file into the array pointed to by \a str, until
-   * \a num - 1 bytes are read, or a delimiter is read and transferred to
-   * \a str, or end-of-file is encountered. The string is then terminated
-   * with a null byte.
-   *
-   * fgets() deletes CR, '\\r', from the string.  This insures only a '\\n'
-   * terminates the string for Windows text files which use CRLF for newline.
-   *
-   * \param[out] str Pointer to the array where the string is stored.
-   * \param[in] num Maximum number of characters to be read
-   * (including the final null byte). Usually the length
-   * of the array \a str is used.
-   * \param[in] delim Optional set of delimiters. The default is "\n".
-   *
-   * \return For success fgets() returns the length of the string in \a str.
-   * If no data is read, fgets() returns zero for EOF or -1 if an error
-   * occurred.
-   */
-  int fgets(char* str, int num, char* delim = nullptr);
-  /** \return The total number of bytes in a file. */
-  uint32_t fileSize() const {return m_fileSize;}
-  /** \return first sector of file or zero for empty file. */
-  uint32_t firstBlock() const {return firstSector();}
-  /** \return Address of first sector or zero for empty file. */
-  uint32_t firstSector() const;
-  /** Arduino name for sync() */
-  void flush() {sync();}
-  /** set position for streams
-   * \param[in] pos struct with value for new position
-   */
-  void fsetpos(const fspos_t* pos);
-  /** Get a file's access date.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getAccessDate(uint16_t* pdate);
-  /** Get a file's access date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime return zero since FAT has no time.
-   *
-   * This function is for comparability in FsFile.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getAccessDateTime(uint16_t* pdate, uint16_t* ptime) {
-    if (!getAccessDate(pdate)) {
-      return false;
-    }
-    *ptime = 0;
-    return true;
-  }
-  /** Get a file's create date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime Packed time for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getCreateDateTime(uint16_t* pdate, uint16_t* ptime);
-  /** \return All error bits. */
-  uint8_t getError() const {return m_error;}
-  /** Get a file's modify date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime Packed time for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getModifyDateTime(uint16_t* pdate, uint16_t* ptime);
-  /**
-   * Get a file's name followed by a zero byte.
-   *
-   * \param[out] name An array of characters for the file's name.
-   * \param[in] size The size of the array in bytes. The array
-   *             must be at least 13 bytes long.  The file's name will be
-   *             truncated if the file's name is too long.
-   * \return length for success or zero for failure.
-   */
-  size_t getName(char* name, size_t size);
-  /**
-   * Get a file's ASCII name followed by a zero.
-   *
-   * \param[out] name An array of characters for the file's name.
-   * \param[in] size The size of the array in characters.
-   * \return the name length.
-   */
-  size_t getName7(char* name, size_t size);
-  /**
-   * Get a file's UTF-8 name followed by a zero.
-   *
-   * \param[out] name An array of characters for the file's name.
-   * \param[in] size The size of the array in characters.
-   * \return the name length.
-   */
-  size_t getName8(char* name, size_t size);
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  size_t __attribute__((error("use getSFN(name, size)"))) getSFN(char* name);
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  /**
-   * Get a file's Short File Name followed by a zero byte.
-   *
-   * \param[out] name An array of characters for the file's name.
-   *                  The array should be at least 13 bytes long.
-   * \param[in] size size of name array.
-   * \return true for success or false for failure.
-   */
-  size_t getSFN(char* name, size_t size);
-  /** \return value of writeError */
-  bool getWriteError() const {
-    return isOpen() ? m_error & WRITE_ERROR : true;
-  }
-  /**
-   * Check for device busy.
-   *
-   * \return true if busy else false.
-   */
-  bool isBusy();
-#if USE_FAT_FILE_FLAG_CONTIGUOUS
-    /** \return True if the file is contiguous. */
-  bool isContiguous() const {return m_flags & FILE_FLAG_CONTIGUOUS;}
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-  /** \return True if this is a directory. */
-  bool isDir() const {return m_attributes & FILE_ATTR_DIR;}
-  /** \return True if this is a normal file. */
-  bool isFile() const {return m_attributes & FILE_ATTR_FILE;}
-  /** \return True if this is a normal file or sub-directory. */
-  bool isFileOrSubDir() const {return isFile() || isSubDir();}
-  /** \return True if this is a hidden file. */
-  bool isHidden() const {return m_attributes & FS_ATTRIB_HIDDEN;}
-  /** \return true if this file has a Long File Name. */
-  bool isLFN() const {return m_lfnOrd;}
-  /** \return True if this is an open file/directory. */
-  bool isOpen() const {return m_attributes;}
-  /** \return True file is readable. */
-  bool isReadable() const {return m_flags & FILE_FLAG_READ;}
-  /** \return True if file is read-only */
-  bool isReadOnly() const {return m_attributes & FS_ATTRIB_READ_ONLY;}
-  /** \return True if this is the root directory. */
-  bool isRoot() const {return m_attributes & FILE_ATTR_ROOT;}
-  /** \return True if this is the FAT32 root directory. */
-  bool isRoot32() const {return m_attributes & FILE_ATTR_ROOT32;}
-  /** \return True if this is the FAT12 of FAT16 root directory. */
-  bool isRootFixed() const {return m_attributes & FILE_ATTR_ROOT_FIXED;}
-  /** \return True if this is a sub-directory. */
-  bool isSubDir() const {return m_attributes & FILE_ATTR_SUBDIR;}
-  /** \return True if this is a system file. */
-  bool isSystem() const {return m_attributes & FS_ATTRIB_SYSTEM;}
-  /** \return True file is writable. */
-  bool isWritable() const {return m_flags & FILE_FLAG_WRITE;}
-  /** List directory contents.
-   *
-   * \param[in] pr Print stream for list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \param[in] indent Amount of space before file name. Used for recursive
-   * list to indicate subdirectory level.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, uint8_t flags = 0, uint8_t indent = 0);
-  /** Make a new directory.
-   *
-   * \param[in] dir An open FatFile instance for the directory that will
-   *                   contain the new directory.
-   *
-   * \param[in] path A path with a valid name for the new directory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(FatFile* dir, const char* path, bool pFlag = true);
-  /** Open a file in the volume root directory.
-   *
-   * \param[in] vol Volume where the file is located.
-   *
-   * \param[in] path with a valid name for a file to be opened.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see FatFile::open(FatFile*, const char*, uint8_t).
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(FatVolume* vol, const char* path, oflag_t oflag = O_RDONLY);
-  /** Open a file by index.
-   *
-   * \param[in] dirFile An open FatFile instance for the directory.
-   *
-   * \param[in] index The \a index of the directory entry for the file to be
-   * opened.  The value for \a index is (directory file position)/32.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see FatFile::open(FatFile*, const char*, uint8_t).
-   *
-   * See open() by path for definition of flags.
-   * \return true for success or false for failure.
-   */
-  bool open(FatFile* dirFile, uint16_t index, oflag_t oflag = O_RDONLY);
-  /** Open a file by index in the current working directory.
-   *
-   * \param[in] index The \a index of the directory entry for the file to be
-   * opened.  The value for \a index is (directory file position)/32.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see FatFile::open(FatFile*, const char*, uint8_t).
-   *
-   * See open() by path for definition of flags.
-   * \return true for success or false for failure.
-   */
-  bool open(uint16_t index, oflag_t oflag = O_RDONLY);
-  /** Open a file or directory by name.
-   *
-   * \param[in] dirFile An open FatFile instance for the directory containing
-   *                    the file to be opened.
-   *
-   * \param[in] path A path with a valid name for a file to be opened.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a
-   *                  bitwise-inclusive OR of flags from the following list.
-   *                  Only one of O_RDONLY, O_READ, O_WRONLY, O_WRITE, or
-   *                  O_RDWR is allowed.
-   *
-   * O_RDONLY - Open for reading.
-   *
-   * O_READ - Same as O_RDONLY.
-   *
-   * O_WRONLY - Open for writing.
-   *
-   * O_WRITE - Same as O_WRONLY.
-   *
-   * O_RDWR - Open for reading and writing.
-   *
-   * O_APPEND - If set, the file offset shall be set to the end of the
-   * file prior to each write.
-   *
-   * O_AT_END - Set the initial position at the end of the file.
-   *
-   * O_CREAT - If the file exists, this flag has no effect except as noted
-   * under O_EXCL below. Otherwise, the file shall be created
-   *
-   * O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file
-   * exists.
-   *
-   * O_TRUNC - If the file exists and is a regular file, and the file is
-   * successfully opened and is not read only, its length shall be truncated
-   * to 0.
-   *
-   * WARNING: A given file must not be opened by more than one FatFile object
-   * or file corruption may occur.
-   *
-   * \note Directory files must be opened read only.  Write and truncation is
-   * not allowed for directory files.
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(FatFile* dirFile, const char* path, oflag_t oflag = O_RDONLY);
-  /** Open a file in the current working volume.
-   *
-   * \param[in] path A path with a valid name for a file to be opened.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see FatFile::open(FatFile*, const char*, uint8_t).
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(const char* path, oflag_t oflag = O_RDONLY);
-   /** Open the current working directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool openCwd();
-  /** Open existing file wih Short 8.3 names.
-   * \param[in] path with short 8.3 names.
-   *
-   * the purpose of this function is to save flash on Uno
-   * and other small boards.
-   *
-   * Directories will be opened O_RDONLY, files O_RDWR.
-   * \return true for success or false for failure.
-   */
-  bool openExistingSFN(const char* path);
-  /** Open the next file or subdirectory in a directory.
-   *
-   * \param[in] dirFile An open FatFile instance for the directory
-   *                    containing the file to be opened.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *                  See see FatFile::open(FatFile*, const char*, uint8_t).
-   *
-   * \return true for success or false for failure.
-   */
-  bool openNext(FatFile* dirFile, oflag_t oflag = O_RDONLY);
-  /** Open a volume's root directory.
-   *
-   * \param[in] vol The FAT volume containing the root directory to be opened.
-   *
-   * \return true for success or false for failure.
-   */
-  bool openRoot(FatVolume* vol);
-
-  /** Return the next available byte without consuming it.
-   *
-   * \return The byte if no error and not at eof else -1;
-   */
-  int peek();
-  /** Allocate contiguous clusters to an empty file.
-   *
-   * The file must be empty with no clusters allocated.
-   *
-   * The file will contain uninitialized data.
-   *
-   * \param[in] length size of the file in bytes.
-   * \return true for success or false for failure.
-   */
-  bool preAllocate(uint32_t length);
-  /** Print a file's access date
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return The number of characters printed.
-   */
-  size_t printAccessDate(print_t* pr);
-  /** Print a file's access date
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return The number of characters printed.
-   */
-  size_t printAccessDateTime(print_t* pr) {
-    return printAccessDate(pr);
-  }
-  /** Print a file's creation date and time
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return The number of bytes printed.
-   */
-  size_t printCreateDateTime(print_t* pr);
-  /** %Print a directory date field.
-   *
-   *  Format is yyyy-mm-dd.
-   *
-   * \param[in] pr Print stream for output.
-   * \param[in] fatDate The date field from a directory entry.
-   */
-  static void printFatDate(print_t* pr, uint16_t fatDate);
-  /** %Print a directory time field.
-   *
-   * Format is hh:mm:ss.
-   *
-   * \param[in] pr Print stream for output.
-   * \param[in] fatTime The time field from a directory entry.
-   */
-  static void printFatTime(print_t* pr, uint16_t fatTime);
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  size_t printField(double value, char term, uint8_t prec = 2) {
-    char buf[24];
-    char* str = buf + sizeof(buf);
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    str = fmtDouble(str, value, prec, false);
-    return write(str, buf + sizeof(buf) - str);
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  size_t printField(float value, char term, uint8_t prec = 2) {
-    return printField(static_cast<double>(value), term, prec);
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  template <typename Type>
-  size_t printField(Type value, char term) {
-    char sign = 0;
-    char buf[3*sizeof(Type) + 3];
-    char* str = buf + sizeof(buf);
-
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    if (value < 0) {
-      value = -value;
-      sign = '-';
-    }
-    if (sizeof(Type) < 4) {
-      str = fmtBase10(str, (uint16_t)value);
-    } else {
-      str = fmtBase10(str, (uint32_t)value);
-    }
-    if (sign) {
-      *--str = sign;
-    }
-    return write(str, &buf[sizeof(buf)] - str);
-  }
-  /** Print a file's size.
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return The number of characters printed is returned
-   *         for success and zero is returned for failure.
-   */
-  size_t printFileSize(print_t* pr);
-  /** Print a file's modify date and time
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return The number of characters printed.
-   */
-  size_t printModifyDateTime(print_t* pr);
-  /** Print a file's name
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return length for success or zero for failure.
-   */
-  size_t printName(print_t* pr);
-  /** Print a file's ASCII name
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printName7(print_t* pr);
-  /** Print a file's UTF-8 name
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printName8(print_t* pr);
-  /** Print a file's Short File Name.
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return The number of characters printed is returned
-   *         for success and zero is returned for failure.
-   */
-  size_t printSFN(print_t* pr);
-  /** Read the next byte from a file.
-   *
-   * \return For success read returns the next byte in the file as an int.
-   * If an error occurs or end of file is reached -1 is returned.
-   */
-  int read() {
-    uint8_t b;
-    return read(&b, 1) == 1 ? b : -1;
-  }
-  /** Read data from a file starting at the current position.
-   *
-   * \param[out] buf Pointer to the location that will receive the data.
-   *
-   * \param[in] count Maximum number of bytes to read.
-   *
-   * \return For success read() returns the number of bytes read.
-   * A value less than \a nbyte, including zero, will be returned
-   * if end of file is reached.
-   * If an error occurs, read() returns -1.
-   */
-  int read(void* buf, size_t count);
-  /** Read the next directory entry from a directory file.
-   *
-   * \param[out] dir The DirFat_t struct that will receive the data.
-   *
-   * \return For success readDir() returns the number of bytes read.
-   * A value of zero will be returned if end of file is reached.
-   * If an error occurs, readDir() returns -1.  Possible errors include
-   * readDir() called before a directory has been opened, this is not
-   * a directory file or an I/O error occurred.
-   */
-  int8_t readDir(DirFat_t* dir);
-  /** Remove a file.
-   *
-   * The directory entry and all data for the file are deleted.
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * file that has a long name. For example if a file has the long name
-   * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove();
-  /** Remove a file.
-   *
-   * The directory entry and all data for the file are deleted.
-   *
-   * \param[in] path Path for the file to be removed.
-   *
-   * Example use: dirFile.remove(filenameToRemove);
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * file that has a long name. For example if a file has the long name
-   * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove(const char* path);
-  /** Rename a file or subdirectory.
-   * \note the renamed file will be moved to the current volume working
-   * directory.
-   *
-   * \param[in] newPath New path name for the file/directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const char* newPath);
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] dirFile Directory for the new path.
-   * \param[in] newPath New path name for the file/directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(FatFile* dirFile, const char* newPath);
-  /** Set the file's current position to zero. */
-  void rewind() {
-    seekSet(0);
-  }
-  /** Remove a directory file.
-   *
-   * The directory file will be removed only if it is empty and is not the
-   * root directory.  rmdir() follows DOS and Windows and ignores the
-   * read-only attribute for the directory.
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * directory that has a long name. For example if a directory has the
-   * long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir();
-  /** Recursively delete a directory and all contained files.
-   *
-   * This is like the Unix/Linux 'rm -rf *' if called with the root directory
-   * hence the name.
-   *
-   * Warning - This will remove all contents of the directory including
-   * subdirectories.  The directory will then be removed if it is not root.
-   * The read-only attribute for files will be ignored.
-   *
-   * \note This function should not be used to delete the 8.3 version of
-   * a directory that has a long name.  See remove() and rmdir().
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmRfStar();
-  /** Set the files position to current position + \a pos. See seekSet().
-   * \param[in] offset The new position in bytes from the current position.
-   * \return true for success or false for failure.
-   */
-  bool seekCur(int32_t offset) {
-    return seekSet(m_curPosition + offset);
-  }
-  /** Set the files position to end-of-file + \a offset. See seekSet().
-   * Can't be used for directory files since file size is not defined.
-   * \param[in] offset The new position in bytes from end-of-file.
-   * \return true for success or false for failure.
-   */
-  bool seekEnd(int32_t offset = 0) {
-    return isFile() ? seekSet(m_fileSize + offset) : false;
-  }
-  /** Sets a file's position.
-   *
-   * \param[in] pos The new position in bytes from the beginning of the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool seekSet(uint32_t pos);
-  /** The sync() call causes all modified data and directory fields
-   * to be written to the storage device.
-   *
-   * \return true for success or false for failure.
-   */
-  bool sync();
-  /** Set a file's timestamps in its directory entry.
-   *
-   * \param[in] flags Values for \a flags are constructed by a bitwise-inclusive
-   * OR of flags from the following list
-   *
-   * T_ACCESS - Set the file's last access date.
-   *
-   * T_CREATE - Set the file's creation date and time.
-   *
-   * T_WRITE - Set the file's last write/modification date and time.
-   *
-   * \param[in] year Valid range 1980 - 2107 inclusive.
-   *
-   * \param[in] month Valid range 1 - 12 inclusive.
-   *
-   * \param[in] day Valid range 1 - 31 inclusive.
-   *
-   * \param[in] hour Valid range 0 - 23 inclusive.
-   *
-   * \param[in] minute Valid range 0 - 59 inclusive.
-   *
-   * \param[in] second Valid range 0 - 59 inclusive
-   *
-   * \note It is possible to set an invalid date since there is no check for
-   * the number of days in a month.
-   *
-   * \note
-   * Modify and access timestamps may be overwritten if a date time callback
-   * function has been set by dateTimeCallback().
-   *
-   * \return true for success or false for failure.
-   */
-  bool timestamp(uint8_t flags, uint16_t year, uint8_t month, uint8_t day,
-                 uint8_t hour, uint8_t minute, uint8_t second);
-
-  /** Truncate a file at the current file position.
-   * will be maintained if it is less than or equal to \a length otherwise
-   * it will be set to end of file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate();
-  /** Truncate a file to a specified length.  The current file position
-   * will be set to end of file.
-   *
-   * \param[in] length The desired length for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate(uint32_t length) {
-    return seekSet(length) && truncate();
-  }
-  /** Write a string to a file. Used by the Arduino Print class.
-   * \param[in] str Pointer to the string.
-   * Use getWriteError to check for errors.
-   * \return count of characters written for success or -1 for failure.
-   */
-  size_t write(const char* str) {
-    return write(str, strlen(str));
-  }
-  /** Write a single byte.
-   * \param[in] b The byte to be written.
-   * \return +1 for success or -1 for failure.
-   */
-  size_t write(uint8_t b) {
-    return write(&b, 1);
-  }
-  /** Write data to an open file.
-   *
-   * \note Data is moved to the cache but may not be written to the
-   * storage device until sync() is called.
-   *
-   * \param[in] buf Pointer to the location of the data to be written.
-   *
-   * \param[in] count Number of bytes to write.
-   *
-   * \return For success write() returns the number of bytes written, always
-   * \a count.  If an error occurs, write() returns zero and writeError is set.
-   *
-   */
-  size_t write(const void* buf, size_t count);
-//------------------------------------------------------------------------------
-#if ENABLE_ARDUINO_SERIAL
-  /** List directory contents.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(uint8_t flags = 0) {
-    return ls(&Serial, flags);
-  }
-  /** Print a file's name.
-   *
-   * \return length for success or zero for failure.
-   */
-  size_t printName() {
-    return FatFile::printName(&Serial);
-  }
-#endif  // ENABLE_ARDUINO_SERIAL
-
- private:
-  /** FatVolume allowed access to private members. */
-  friend class FatVolume;
-
-  /** This file has not been opened. */
-  static const uint8_t FILE_ATTR_CLOSED = 0;
-  /** Entry for normal data file */
-  static const uint8_t FILE_ATTR_FILE = 0X08;
-  /** Entry is for a subdirectory */
-  static const uint8_t FILE_ATTR_SUBDIR = FS_ATTRIB_DIRECTORY;
-  /** A FAT12 or FAT16 root directory */
-  static const uint8_t FILE_ATTR_ROOT_FIXED = 0X40;
-  /** A FAT32 root directory */
-  static const uint8_t FILE_ATTR_ROOT32 = 0X80;
-  /** Entry is for root. */
-  static const uint8_t FILE_ATTR_ROOT =
-                       FILE_ATTR_ROOT_FIXED | FILE_ATTR_ROOT32;
-  /** Directory type bits */
-  static const uint8_t FILE_ATTR_DIR = FILE_ATTR_SUBDIR | FILE_ATTR_ROOT;
-
-  // private functions
-
-  bool addCluster();
-  bool addDirCluster();
-  DirFat_t* cacheDir(uint16_t index) {
-    return seekSet(32UL*index) ? readDirCache() : nullptr;
-  }
-  DirFat_t* cacheDirEntry(uint8_t action);
-  bool cmpName(uint16_t index, FatLfn_t* fname, uint8_t lfnOrd);
-  bool createLFN(uint16_t index, FatLfn_t* fname, uint8_t lfnOrd);
-  uint16_t getLfnChar(DirLfn_t* ldir, uint8_t i);
-  uint8_t lfnChecksum(uint8_t* name) {
-    uint8_t sum = 0;
-    for (uint8_t i = 0; i < 11; i++) {
-        sum = (((sum & 1) << 7) | (sum >> 1)) + name[i];
-    }
-    return sum;
-  }
-  static bool makeSFN(FatLfn_t* fname);
-  bool makeUniqueSfn(FatLfn_t* fname);
-  bool openCluster(FatFile* file);
-  bool parsePathName(const char* str, FatLfn_t* fname, const char** ptr);
-  bool parsePathName(const char* str, FatSfn_t* fname, const char** ptr);
-  bool mkdir(FatFile* parent, FatName_t* fname);
-  bool open(FatFile* dirFile, FatLfn_t* fname, oflag_t oflag);
-  bool open(FatFile* dirFile, FatSfn_t* fname, oflag_t oflag);
-  bool openSFN(FatSfn_t* fname);
-  bool openCachedEntry(FatFile* dirFile, uint16_t cacheIndex, oflag_t oflag,
-                       uint8_t lfnOrd);
-  DirFat_t* readDirCache(bool skipReadOk = false);
-
-  // bits defined in m_flags
-  static const uint8_t FILE_FLAG_READ = 0X01;
-  static const uint8_t FILE_FLAG_WRITE = 0X02;
-  static const uint8_t FILE_FLAG_APPEND = 0X08;
-  // treat curPosition as valid length.
-  static const uint8_t FILE_FLAG_PREALLOCATE = 0X20;
-  // file is contiguous
-  static const uint8_t FILE_FLAG_CONTIGUOUS  = 0X40;
-  // sync of directory entry required
-  static const uint8_t FILE_FLAG_DIR_DIRTY = 0X80;
-
-  // private data
-  static const uint8_t WRITE_ERROR = 0X1;
-  static const uint8_t READ_ERROR  = 0X2;
-
-  uint8_t    m_attributes = FILE_ATTR_CLOSED;
-  uint8_t    m_error = 0;        // Error bits.
-  uint8_t    m_flags = 0;        // See above for definition of m_flags bits
-  uint8_t    m_lfnOrd;
-  uint16_t   m_dirIndex;         // index of directory entry in dir file
-  FatVolume* m_vol;              // volume where file is located
-  uint32_t   m_dirCluster;
-  uint32_t   m_curCluster;       // cluster for current file position
-  uint32_t   m_curPosition;      // current file position
-  uint32_t   m_dirSector;        // sector for this files directory entry
-  uint32_t   m_fileSize;         // file size in bytes
-  uint32_t   m_firstCluster;     // first cluster of file
-};
-
-#include "../common/ArduinoFiles.h"
-/**
- * \class File32
- * \brief FAT16/FAT32 file with Arduino Stream.
- */
-class File32 : public StreamFile<FatFile, uint32_t> {
- public:
-   /** Opens the next file or folder in a directory.
-   *
-   * \param[in] oflag open flags.
-   * \return a FatStream object.
-   */
-  File32 openNextFile(oflag_t oflag = O_RDONLY) {
-    File32 tmpFile;
-    tmpFile.openNext(this, oflag);
-    return tmpFile;
-  }
-};
-#endif  // FatFile_h

lib/SdFat_NoArduino/src/FatLib/FatFileLFN.cpp

@@ -1,595 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "FatFileLFN.cpp"
-#include "../common/DebugMacros.h"
-#include "../common/upcase.h"
-#include "../common/FsUtf.h"
-#include "FatLib.h"
-#if USE_LONG_FILE_NAMES
-//------------------------------------------------------------------------------
-static bool isLower(char c) {
-  return 'a' <= c && c <= 'z';
-}
-//------------------------------------------------------------------------------
-static bool isUpper(char c) {
-  return 'A' <= c && c <= 'Z';
-}
-//------------------------------------------------------------------------------
-// A bit smaller than toupper in AVR 328.
-inline char toUpper(char c) {
-  return isLower(c) ? c - 'a' + 'A' : c;
-}
-//------------------------------------------------------------------------------
-/**
- * Store a 16-bit long file name character.
- *
- * \param[in] ldir Pointer to long file name directory entry.
- * \param[in] i Index of character.
- * \param[in] c The 16-bit character.
- */
-static void putLfnChar(DirLfn_t* ldir, uint8_t i, uint16_t c) {
-  if (i < 5) {
-    setLe16(ldir->unicode1 + 2*i, c);
-  } else if (i < 11) {
-    setLe16(ldir->unicode2 + 2*i -10, c);
-  } else if (i < 13) {
-    setLe16(ldir->unicode3 + 2*i - 22, c);
-  }
-}
-//------------------------------------------------------------------------------
-// Daniel Bernstein University of Illinois at Chicago.
-// Original had + instead of ^
-__attribute__((unused))
-static uint16_t Bernstein(const char* bgn, const char* end, uint16_t hash) {
-  while (bgn < end) {
-    // hash = hash * 33 ^ str[i];
-    hash = ((hash << 5) + hash) ^ (*bgn++);
-  }
-  return hash;
-}
-//==============================================================================
-bool FatFile::cmpName(uint16_t index, FatLfn_t* fname, uint8_t lfnOrd) {
-  FatFile dir = *this;
-  DirLfn_t* ldir;
-  fname->reset();
-  for (uint8_t order = 1; order <= lfnOrd; order++) {
-    ldir = reinterpret_cast<DirLfn_t*>(dir.cacheDir(index - order));
-    if (!ldir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // These should be checked in caller.
-    DBG_HALT_IF(ldir->attributes != FAT_ATTRIB_LONG_NAME);
-    DBG_HALT_IF(order != (ldir->order & 0X1F));
-    for (uint8_t i = 0; i < 13; i++) {
-      uint16_t u = getLfnChar(ldir, i);
-      if (fname->atEnd()) {
-        return u == 0;
-      }
-#if USE_UTF8_LONG_NAMES
-      uint16_t cp = fname->get16();
-      // Make sure caller checked for valid UTF-8.
-      DBG_HALT_IF(cp == 0XFFFF);
-      if (toUpcase(u) != toUpcase(cp)) {
-        return false;
-      }
-#else  // USE_UTF8_LONG_NAMES
-      if (u > 0X7F || toUpper(u) != toUpper(fname->getch())) {
-        return false;
-      }
-#endif  // USE_UTF8_LONG_NAMES
-    }
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::createLFN(uint16_t index, FatLfn_t* fname, uint8_t lfnOrd) {
-  FatFile dir = *this;
-  DirLfn_t* ldir;
-  uint8_t checksum = lfnChecksum(fname->sfn);
-  uint8_t fc = 0;
-  fname->reset();
-
-  for (uint8_t order = 1; order <= lfnOrd; order++) {
-    ldir = reinterpret_cast<DirLfn_t*>(dir.cacheDir(index - order));
-    if (!ldir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    dir.m_vol->cacheDirty();
-    ldir->order = order == lfnOrd ? FAT_ORDER_LAST_LONG_ENTRY | order : order;
-    ldir->attributes = FAT_ATTRIB_LONG_NAME;
-    ldir->mustBeZero1 = 0;
-    ldir->checksum = checksum;
-    setLe16(ldir->mustBeZero2, 0);
-    for (uint8_t i = 0; i < 13; i++) {
-      uint16_t cp;
-      if (fname->atEnd()) {
-        cp = fc++ ? 0XFFFF : 0;
-      } else {
-        cp = fname->get16();
-        // Verify caller checked for valid UTF-8.
-        DBG_HALT_IF(cp == 0XFFFF);
-      }
-      putLfnChar(ldir, i, cp);
-    }
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::makeSFN(FatLfn_t* fname) {
-  bool is83;
-//  char c;
-  uint8_t c;
-  uint8_t bit = FAT_CASE_LC_BASE;
-  uint8_t lc = 0;
-  uint8_t uc = 0;
-  uint8_t i = 0;
-  uint8_t in = 7;
-  const char* dot;
-  const char* end = fname->end;
-  const char* ptr = fname->begin;
-
-  // Assume not zero length.
-  DBG_HALT_IF(end == ptr);
-  // Assume blanks removed from start and end.
-  DBG_HALT_IF(*ptr == ' ' || *(end - 1) == ' ' || *(end - 1) == '.');
-
-  // Blank file short name.
-  for (uint8_t k = 0; k < 11; k++) {
-    fname->sfn[k] = ' ';
-  }
-  // Not 8.3 if starts with dot.
-  is83 = *ptr == '.' ? false : true;
-  // Skip leading dots.
-  for (; *ptr == '.'; ptr++) {}
-  // Find last dot.
-  for (dot = end - 1; dot > ptr && *dot != '.'; dot--) {}
-
-  for (; ptr < end; ptr++) {
-    c = *ptr;
-    if (c == '.' && ptr == dot) {
-      in = 10;  // Max index for full 8.3 name.
-      i = 8;    // Place for extension.
-      bit = FAT_CASE_LC_EXT;  // bit for extension.
-    } else {
-      if (sfnReservedChar(c)) {
-        is83 = false;
-        // Skip UTF-8 trailing characters.
-        if ((c & 0XC0) == 0X80) {
-          continue;
-        }
-        c = '_';
-      }
-      if (i > in) {
-        is83 = false;
-        if (in == 10 || ptr > dot) {
-         // Done - extension longer than three characters or no extension.
-          break;
-        }
-        // Skip to dot.
-        ptr = dot - 1;
-        continue;
-      }
-      if (isLower(c)) {
-        c += 'A' - 'a';
-        lc |= bit;
-      } else if (isUpper(c)) {
-        uc |= bit;
-      }
-      fname->sfn[i++] = c;
-      if (i < 7) {
-        fname->seqPos = i;
-      }
-    }
-  }
-  if (fname->sfn[0] == ' ') {
-    DBG_HALT_MACRO;
-    goto fail;
-  }
-  if (is83) {
-    fname->flags = lc & uc ? FNAME_FLAG_MIXED_CASE : lc;
-  } else {
-    fname->flags = FNAME_FLAG_LOST_CHARS;
-    fname->sfn[fname->seqPos] = '~';
-    fname->sfn[fname->seqPos + 1] = '1';
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::makeUniqueSfn(FatLfn_t* fname) {
-  const uint8_t FIRST_HASH_SEQ = 2;  // min value is 2
-  uint8_t pos = fname->seqPos;
-  DirFat_t* dir;
-  uint16_t hex = 0;
-
-  DBG_HALT_IF(!(fname->flags & FNAME_FLAG_LOST_CHARS));
-  DBG_HALT_IF(fname->sfn[pos] != '~' && fname->sfn[pos + 1] != '1');
-
-  for (uint8_t seq = FIRST_HASH_SEQ; seq < 100; seq++) {
-     DBG_WARN_IF(seq > FIRST_HASH_SEQ);
-#ifdef USE_LFN_HASH
-    hex = Bernstein(fname->begin, fname->end, seq);
-#else
-    hex += millis();
-#endif
-    if (pos > 3) {
-      // Make space in name for ~HHHH.
-      pos = 3;
-    }
-    for (uint8_t i = pos + 4 ; i > pos; i--) {
-      uint8_t h = hex & 0XF;
-      fname->sfn[i] = h < 10 ? h + '0' : h + 'A' - 10;
-      hex >>= 4;
-    }
-    fname->sfn[pos] = '~';
-    rewind();
-    while (1) {
-      dir = readDirCache(true);
-      if (!dir) {
-        if (!getError()) {
-          // At EOF and name not found if no error.
-          goto done;
-        }
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      if (dir->name[0] == FAT_NAME_FREE) {
-        goto done;
-      }
-      if (isFatFileOrSubdir(dir) && !memcmp(fname->sfn, dir->name, 11)) {
-        // Name found - try another.
-        break;
-      }
-    }
-  }
-  // fall inti fail - too many tries.
-  DBG_FAIL_MACRO;
-
- fail:
-  return false;
-
- done:
-  return true;
-}
-//------------------------------------------------------------------------------
-bool FatFile::open(FatFile* dirFile, FatLfn_t* fname, oflag_t oflag) {
-  bool fnameFound = false;
-  uint8_t lfnOrd = 0;
-  uint8_t freeNeed;
-  uint8_t freeFound = 0;
-  uint8_t order = 0;
-  uint8_t checksum = 0;
-  uint8_t ms10;
-  uint8_t nameOrd;
-  uint16_t freeIndex = 0;
-  uint16_t curIndex;
-  uint16_t date;
-  uint16_t time;
-  DirFat_t* dir;
-  DirLfn_t* ldir;
-  auto vol = dirFile->m_vol;
-
-  if (!dirFile->isDir() || isOpen()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Number of directory entries needed.
-  nameOrd = (fname->len + 12)/13;
-  freeNeed = fname->flags & FNAME_FLAG_NEED_LFN ? 1 + nameOrd : 1;
-  dirFile->rewind();
-  while (1) {
-    curIndex = dirFile->m_curPosition/FS_DIR_SIZE;
-    dir = dirFile->readDirCache();
-    if (!dir) {
-      if (dirFile->getError()) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      // At EOF
-      goto create;
-    }
-    if (dir->name[0] == FAT_NAME_DELETED || dir->name[0] == FAT_NAME_FREE) {
-      if (freeFound == 0) {
-        freeIndex = curIndex;
-      }
-      if (freeFound < freeNeed) {
-        freeFound++;
-      }
-      if (dir->name[0] == FAT_NAME_FREE) {
-        goto create;
-      }
-    } else {
-      if (freeFound < freeNeed) {
-        freeFound = 0;
-      }
-    }
-    // skip empty slot or '.' or '..'
-    if (dir->name[0] == FAT_NAME_DELETED || dir->name[0] == '.') {
-      lfnOrd = 0;
-    } else if (isFatLongName(dir)) {
-      ldir = reinterpret_cast<DirLfn_t*>(dir);
-      if (!lfnOrd) {
-        order = ldir->order & 0X1F;
-        if (order != nameOrd ||
-          (ldir->order & FAT_ORDER_LAST_LONG_ENTRY) == 0) {
-          continue;
-        }
-        lfnOrd = nameOrd;
-        checksum = ldir->checksum;
-      } else if (ldir->order != --order || checksum != ldir->checksum) {
-        lfnOrd = 0;
-        continue;
-      }
-      if (order == 1) {
-        if (!dirFile->cmpName(curIndex + 1, fname, lfnOrd)) {
-          lfnOrd = 0;
-        }
-      }
-    } else if (isFatFileOrSubdir(dir)) {
-      if (lfnOrd) {
-        if (1 == order && lfnChecksum(dir->name) == checksum) {
-          goto found;
-        }
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      if (!memcmp(dir->name, fname->sfn, sizeof(fname->sfn))) {
-        if (!(fname->flags & FNAME_FLAG_LOST_CHARS)) {
-          goto found;
-        }
-        fnameFound = true;
-      }
-    } else {
-      lfnOrd = 0;
-    }
-  }
-
- found:
-  // Don't open if create only.
-  if (oflag & O_EXCL) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  goto open;
-
- create:
-  // don't create unless O_CREAT and write mode
-  if (!(oflag & O_CREAT) || !isWriteMode(oflag)) {
-    DBG_WARN_MACRO;
-    goto fail;
-  }
-  // Keep found entries or start at current index if no free entries found.
-  if (freeFound == 0) {
-    freeIndex = curIndex;
-  }
-
-  while (freeFound < freeNeed) {
-    dir = dirFile->readDirCache();
-    if (!dir) {
-      if (dirFile->getError()) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      // EOF if no error.
-      break;
-    }
-    freeFound++;
-  }
-  while (freeFound < freeNeed) {
-    // Will fail if FAT16 root.
-    if (!dirFile->addDirCluster()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    freeFound += vol->dirEntriesPerCluster();
-  }
-  if (fnameFound) {
-    if (!dirFile->makeUniqueSfn(fname)) {
-      goto fail;
-    }
-  }
-  lfnOrd = freeNeed - 1;
-  curIndex = freeIndex + lfnOrd;
-  if (!dirFile->createLFN(curIndex, fname, lfnOrd)) {
-    goto fail;
-  }
-  dir = dirFile->cacheDir(curIndex);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // initialize as empty file
-  memset(dir, 0, sizeof(DirFat_t));
-  memcpy(dir->name, fname->sfn, 11);
-
-  // Set base-name and extension lower case bits.
-  dir->caseFlags = (FAT_CASE_LC_BASE | FAT_CASE_LC_EXT) & fname->flags;
-
-  // Set timestamps.
-  if (FsDateTime::callback) {
-    // call user date/time function
-    FsDateTime::callback(&date, &time, &ms10);
-    setLe16(dir->createDate, date);
-    setLe16(dir->createTime, time);
-    dir->createTimeMs = ms10;
-  } else {
-    setLe16(dir->createDate, FS_DEFAULT_DATE);
-    setLe16(dir->modifyDate, FS_DEFAULT_DATE);
-    setLe16(dir->accessDate, FS_DEFAULT_DATE);
-    if (FS_DEFAULT_TIME) {
-      setLe16(dir->createTime, FS_DEFAULT_TIME);
-      setLe16(dir->modifyTime, FS_DEFAULT_TIME);
-    }
-  }
-  // Force write of entry to device.
-  vol->cacheDirty();
-
- open:
-  // open entry in cache.
-  if (!openCachedEntry(dirFile, curIndex, oflag, lfnOrd)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::parsePathName(const char* path,
-                            FatLfn_t* fname, const char** ptr) {
-  size_t len = 0;
-  // Skip leading spaces.
-  while (*path == ' ') {
-    path++;
-  }
-  fname->begin = path;
-  fname->len = 0;
-  while (*path && !isDirSeparator(*path)) {
-#if USE_UTF8_LONG_NAMES
-    uint32_t cp;
-    // Allow end = path + 4 since path is zero terminated.
-    path = FsUtf::mbToCp(path, path + 4, &cp);
-    if (!path) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    len += cp <= 0XFFFF ? 1 : 2;
-    if (cp < 0X80 && lfnReservedChar(cp)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-#else  // USE_UTF8_LONG_NAMES
-    uint8_t cp = *path++;
-    if (cp >= 0X80 || lfnReservedChar(cp)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    len++;
-#endif  // USE_UTF8_LONG_NAMES
-    if (cp != '.' && cp != ' ') {
-      // Need to trim trailing dots spaces.
-      fname->len = len;
-      fname->end = path;
-    }
-  }
-  if (!fname->len || fname->len > FAT_MAX_LFN_LENGTH) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Advance to next path component.
-  for (; *path == ' ' || isDirSeparator(*path); path++) {}
-  *ptr = path;
-  return makeSFN(fname);
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::remove() {
-  bool last;
-  uint8_t checksum;
-  FatFile dirFile;
-  DirFat_t* dir;
-  DirLfn_t* ldir;
-
-  // Cant' remove not open for write.
-  if (!isWritable()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Free any clusters.
-  if (m_firstCluster && !m_vol->freeChain(m_firstCluster)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Cache directory entry.
-  dir = cacheDirEntry(FsCache::CACHE_FOR_WRITE);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  checksum = lfnChecksum(dir->name);
-
-  // Mark entry deleted.
-  dir->name[0] = FAT_NAME_DELETED;
-
-  // Set this file closed.
-  m_attributes = FILE_ATTR_CLOSED;
-  m_flags = 0;
-
-  // Write entry to device.
-  if (!m_vol->cacheSync()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!isLFN()) {
-    // Done, no LFN entries.
-    return true;
-  }
-  if (!dirFile.openCluster(this)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  for (uint8_t order = 1; order <= m_lfnOrd; order++) {
-    ldir = reinterpret_cast<DirLfn_t*>(dirFile.cacheDir(m_dirIndex - order));
-    if (!ldir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (ldir->attributes != FAT_ATTRIB_LONG_NAME ||
-        order != (ldir->order & 0X1F) ||
-        checksum != ldir->checksum) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    last = ldir->order & FAT_ORDER_LAST_LONG_ENTRY;
-    ldir->order = FAT_NAME_DELETED;
-    m_vol->cacheDirty();
-    if (last) {
-      if (!m_vol->cacheSync()) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      return true;
-    }
-  }
-  // Fall into fail.
-  DBG_FAIL_MACRO;
-
- fail:
-  return false;
-}
-#endif  // #if USE_LONG_FILE_NAMES

lib/SdFat_NoArduino/src/FatLib/FatFilePrint.cpp

@@ -1,109 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include <math.h>
-#define DBG_FILE "FatFilePrint.cpp"
-#include "../common/DebugMacros.h"
-#include "FatLib.h"
-
-//------------------------------------------------------------------------------
-bool FatFile::ls(print_t* pr, uint8_t flags, uint8_t indent) {
-  FatFile file;
-  if (!isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  rewind();
-  while (file.openNext(this, O_RDONLY)) {
-    // indent for dir level
-    if (!file.isHidden() || (flags & LS_A)) {
-      for (uint8_t i = 0; i < indent; i++) {
-        pr->write(' ');
-      }
-      if (flags & LS_DATE) {
-        file.printModifyDateTime(pr);
-        pr->write(' ');
-      }
-      if (flags & LS_SIZE) {
-        file.printFileSize(pr);
-        pr->write(' ');
-      }
-      file.printName(pr);
-      if (file.isDir()) {
-        pr->write('/');
-      }
-      pr->write('\r');
-      pr->write('\n');
-      if ((flags & LS_R) && file.isDir()) {
-        file.ls(pr, flags, indent + 2);
-      }
-    }
-    file.close();
-  }
-  if (getError()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::printAccessDate(print_t* pr) {
-  uint16_t date;
-  if (getAccessDate(&date)) {
-    return fsPrintDate(pr, date);
-  }
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::printCreateDateTime(print_t* pr) {
-  uint16_t date;
-  uint16_t time;
-  if (getCreateDateTime(&date, &time)) {
-    return fsPrintDateTime(pr, date, time);
-  }
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::printModifyDateTime(print_t* pr) {
-  uint16_t date;
-  uint16_t time;
-  if (getModifyDateTime(&date, &time)) {
-    return fsPrintDateTime(pr, date, time);
-  }
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::printFileSize(print_t* pr) {
-  char buf[11];
-  char *ptr = buf + sizeof(buf);
-  *--ptr = 0;
-  ptr = fmtBase10(ptr, fileSize());
-  while (ptr > buf) {
-    *--ptr = ' ';
-  }
-  return pr->write(buf);
-}

lib/SdFat_NoArduino/src/FatLib/FatFileSFN.cpp

@@ -1,315 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "FatFileSFN.cpp"
-#include "../common/DebugMacros.h"
-#include "FatLib.h"
-//------------------------------------------------------------------------------
-// open with filename in fname
-#define SFN_OPEN_USES_CHKSUM 0
-bool FatFile::open(FatFile* dirFile, FatSfn_t* fname, oflag_t oflag) {
-  uint16_t date;
-  uint16_t time;
-  uint8_t ms10;
-  bool emptyFound = false;
-#if SFN_OPEN_USES_CHKSUM
-  uint8_t checksum;
-#endif  // SFN_OPEN_USES_CHKSUM
-  uint8_t lfnOrd = 0;
-  uint16_t emptyIndex = 0;
-  uint16_t index = 0;
-  DirFat_t* dir;
-  DirLfn_t* ldir;
-
-  dirFile->rewind();
-  while (true) {
-    dir = dirFile->readDirCache(true);
-    if (!dir) {
-      if (dirFile->getError())  {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      // At EOF if no error.
-      break;
-    }
-    if (dir->name[0] == FAT_NAME_DELETED || dir->name[0] == FAT_NAME_FREE) {
-      if (!emptyFound) {
-        emptyIndex = index;
-        emptyFound = true;
-      }
-      if (dir->name[0] == FAT_NAME_FREE) {
-        break;
-      }
-      lfnOrd = 0;
-    } else if (isFatFileOrSubdir(dir)) {
-      if (!memcmp(fname->sfn, dir->name, 11)) {
-        // don't open existing file if O_EXCL
-        if (oflag & O_EXCL) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-#if SFN_OPEN_USES_CHKSUM
-        if (lfnOrd && checksum != lfnChecksum(dir->name)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-#endif  // SFN_OPEN_USES_CHKSUM
-        if (!openCachedEntry(dirFile, index, oflag, lfnOrd)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        return true;
-      } else {
-        lfnOrd = 0;
-      }
-    } else if (isFatLongName(dir)) {
-      ldir = reinterpret_cast<DirLfn_t*>(dir);
-      if (ldir->order & FAT_ORDER_LAST_LONG_ENTRY) {
-        lfnOrd = ldir->order & 0X1F;
-#if SFN_OPEN_USES_CHKSUM
-        checksum = ldir->checksum;
-#endif  // SFN_OPEN_USES_CHKSUM
-      }
-    } else {
-      lfnOrd = 0;
-    }
-    index++;
-  }
-  // don't create unless O_CREAT and write mode
-  if (!(oflag & O_CREAT) || !isWriteMode(oflag)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (emptyFound) {
-    index = emptyIndex;
-  } else {
-    if (!dirFile->addDirCluster()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  dir = reinterpret_cast<DirFat_t*>(dirFile->cacheDir(index));
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // initialize as empty file
-  memset(dir, 0, sizeof(DirFat_t));
-  memcpy(dir->name, fname->sfn, 11);
-
-  // Set base-name and extension lower case bits.
-  dir->caseFlags = (FAT_CASE_LC_BASE | FAT_CASE_LC_EXT) & fname->flags;
-
-  // Set timestamps.
-  if (FsDateTime::callback) {
-    // call user date/time function
-    FsDateTime::callback(&date, &time, &ms10);
-    setLe16(dir->createDate, date);
-    setLe16(dir->createTime, time);
-    dir->createTimeMs = ms10;
-  } else {
-    setLe16(dir->createDate, FS_DEFAULT_DATE);
-    setLe16(dir->modifyDate, FS_DEFAULT_DATE);
-    setLe16(dir->accessDate, FS_DEFAULT_DATE);
-    if (FS_DEFAULT_TIME) {
-      setLe16(dir->createTime, FS_DEFAULT_TIME);
-      setLe16(dir->modifyTime, FS_DEFAULT_TIME);
-    }
-  }
-  // Force write of entry to device.
-  dirFile->m_vol->cacheDirty();
-
-  // open entry in cache.
-  return openCachedEntry(dirFile, index, oflag, 0);
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::openExistingSFN(const char* path) {
-  FatSfn_t fname;
-  auto vol = FatVolume::cwv();
-  while (*path == '/') {
-    path++;
-  }
-  if (*path == 0) {
-    return openRoot(vol);
-  }
-  *this = *vol->vwd();
-  do {
-    if (!parsePathName(path, &fname, &path)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (!openSFN(&fname)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  } while (*path);
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FatFile::openSFN(FatSfn_t* fname) {
-  DirFat_t dir;
-  DirLfn_t* ldir;
-  auto vol = m_vol;
-  uint8_t lfnOrd = 0;
-  if (!isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  while (true) {
-    if (read(&dir, 32) != 32) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (dir.name[0] == 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (isFatFileOrSubdir(&dir) && memcmp(fname->sfn, dir.name, 11) == 0) {
-      uint16_t dirIndex = (m_curPosition - 32) >> 5;
-      uint32_t dirCluster = m_firstCluster;
-      memset(this, 0 , sizeof(FatFile));
-      m_attributes = dir.attributes & FS_ATTRIB_COPY;
-      m_flags = FILE_FLAG_READ;
-      if (isFatFile(&dir)) {
-        m_attributes |= FILE_ATTR_FILE;
-        if (!isReadOnly()) {
-          m_attributes |= FS_ATTRIB_ARCHIVE;
-          m_flags |= FILE_FLAG_WRITE;
-        }
-      }
-      m_lfnOrd = lfnOrd;
-      m_firstCluster = (uint32_t)getLe16(dir.firstClusterHigh) << 16;
-      m_firstCluster |= getLe16(dir.firstClusterLow);
-      m_fileSize = getLe32(dir.fileSize);
-      m_vol = vol;
-      m_dirCluster = dirCluster;
-      m_dirSector = m_vol->cacheSectorNumber();
-      m_dirIndex = dirIndex;
-      return true;
-    } else if (isFatLongName(&dir)) {
-      ldir = reinterpret_cast<DirLfn_t*>(&dir);
-      if (ldir->order & FAT_ORDER_LAST_LONG_ENTRY) {
-        lfnOrd = ldir->order & 0X1F;
-      }
-    } else {
-      lfnOrd = 0;
-    }
-  }
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-// format directory name field from a 8.3 name string
-bool FatFile::parsePathName(const char* path, FatSfn_t* fname,
-                            const char** ptr) {
-  uint8_t uc = 0;
-  uint8_t lc = 0;
-  uint8_t bit = FNAME_FLAG_LC_BASE;
-  // blank fill name and extension
-  for (uint8_t i = 0; i < 11; i++) {
-    fname->sfn[i] = ' ';
-  }
-  for (uint8_t i = 0, n = 7;; path++) {
-    uint8_t c = *path;
-    if (c == 0 || isDirSeparator(c)) {
-      // Done.
-      break;
-    }
-    if (c == '.' && n == 7) {
-      n = 10;  // max index for full 8.3 name
-      i = 8;   // place for extension
-
-      // bit for extension.
-      bit = FNAME_FLAG_LC_EXT;
-    } else {
-      if (sfnReservedChar(c) || i > n) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      if ('a' <= c && c <= 'z') {
-        c += 'A' - 'a';
-        lc |= bit;
-      } else if ('A' <= c && c <= 'Z') {
-        uc |= bit;
-      }
-      fname->sfn[i++] = c;
-    }
-  }
-  // must have a file name, extension is optional
-  if (fname->sfn[0] == ' ') {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Set base-name and extension bits.
-  fname->flags = lc & uc ? 0 : lc;
-  while (isDirSeparator(*path)) {
-    path++;
-  }
-  *ptr = path;
-  return true;
-
- fail:
-  return false;
-}
-#if !USE_LONG_FILE_NAMES
-//------------------------------------------------------------------------------
-bool FatFile::remove() {
-  DirFat_t* dir;
-  // Can't remove if LFN or not open for write.
-  if (!isWritable() || isLFN()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Free any clusters.
-  if (m_firstCluster && !m_vol->freeChain(m_firstCluster)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Cache directory entry.
-  dir = cacheDirEntry(FsCache::CACHE_FOR_WRITE);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // Mark entry deleted.
-  dir->name[0] = FAT_NAME_DELETED;
-
-  // Set this file closed.
-  m_attributes = FILE_ATTR_CLOSED;
-  m_flags = 0;
-
-  // Write entry to device.
-  return m_vol->cacheSync();
-
- fail:
-  return false;
-}
-#endif  // !USE_LONG_FILE_NAMES

lib/SdFat_NoArduino/src/FatLib/FatFormatter.cpp

@@ -1,280 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FatLib.h"
-// Set nonzero to use calculated CHS in MBR.  Should not be required.
-#define USE_LBA_TO_CHS 1
-
-// Constants for file system structure optimized for flash.
-uint16_t const BU16 = 128;
-uint16_t const BU32 = 8192;
-// Assume 512 byte sectors.
-const uint16_t BYTES_PER_SECTOR = 512;
-const uint16_t SECTORS_PER_MB = 0X100000/BYTES_PER_SECTOR;
-const uint16_t FAT16_ROOT_ENTRY_COUNT = 512;
-const uint16_t FAT16_ROOT_SECTOR_COUNT =
-               32*FAT16_ROOT_ENTRY_COUNT/BYTES_PER_SECTOR;
-//------------------------------------------------------------------------------
-#define PRINT_FORMAT_PROGRESS 1
-#if !PRINT_FORMAT_PROGRESS
-#define writeMsg(str)
-#elif defined(__AVR__)
-#define writeMsg(str) if (m_pr) m_pr->print(F(str))
-#else  // PRINT_FORMAT_PROGRESS
-#define writeMsg(str) if (m_pr) m_pr->write(str)
-#endif  // PRINT_FORMAT_PROGRESS
-//------------------------------------------------------------------------------
-bool FatFormatter::format(FsBlockDevice* dev, uint8_t* secBuf, print_t* pr) {
-  bool rtn;
-  m_dev = dev;
-  m_secBuf = secBuf;
-  m_pr = pr;
-  m_sectorCount = m_dev->sectorCount();
-  m_capacityMB = (m_sectorCount + SECTORS_PER_MB - 1)/SECTORS_PER_MB;
-
-  if (m_capacityMB <= 6) {
-    writeMsg("Card is too small.\r\n");
-    return false;
-  } else if (m_capacityMB <= 16) {
-    m_sectorsPerCluster = 2;
-  } else if (m_capacityMB <= 32) {
-    m_sectorsPerCluster = 4;
-  } else if (m_capacityMB <= 64) {
-    m_sectorsPerCluster = 8;
-  } else if (m_capacityMB <= 128) {
-    m_sectorsPerCluster = 16;
-  } else if (m_capacityMB <= 1024) {
-    m_sectorsPerCluster = 32;
-  } else if (m_capacityMB <= 32768) {
-    m_sectorsPerCluster = 64;
-  } else {
-    // SDXC cards
-    m_sectorsPerCluster = 128;
-  }
-  rtn = m_sectorCount < 0X400000 ? makeFat16() : makeFat32();
-  if (rtn) {
-    writeMsg("Format Done\r\n");
-  } else {
-    writeMsg("Format Failed\r\n");
-  }
-  return rtn;
-}
-//------------------------------------------------------------------------------
-bool FatFormatter::initFatDir(uint8_t fatType, uint32_t sectorCount) {
-  size_t n;
-  memset(m_secBuf, 0, BYTES_PER_SECTOR);
-  writeMsg("Writing FAT ");
-  for (uint32_t i = 1; i < sectorCount; i++) {
-    if (!m_dev->writeSector(m_fatStart + i, m_secBuf)) {
-       return false;
-    }
-    if ((i%(sectorCount/32)) == 0) {
-      writeMsg(".");
-    }
-  }
-  writeMsg("\r\n");
-  // Allocate reserved clusters and root for FAT32.
-  m_secBuf[0] = 0XF8;
-  n = fatType == 16 ? 4 : 12;
-  for (size_t i = 1; i < n; i++) {
-    m_secBuf[i] = 0XFF;
-  }
-  return m_dev->writeSector(m_fatStart, m_secBuf) &&
-         m_dev->writeSector(m_fatStart + m_fatSize, m_secBuf);
-}
-//------------------------------------------------------------------------------
-void FatFormatter::initPbs() {
-  PbsFat_t* pbs = reinterpret_cast<PbsFat_t*>(m_secBuf);
-  memset(m_secBuf, 0, BYTES_PER_SECTOR);
-  pbs->jmpInstruction[0] = 0XEB;
-  pbs->jmpInstruction[1] = 0X76;
-  pbs->jmpInstruction[2] = 0X90;
-  for (uint8_t i = 0; i < sizeof(pbs->oemName); i++) {
-    pbs->oemName[i] = ' ';
-  }
-  setLe16(pbs->bpb.bpb16.bytesPerSector, BYTES_PER_SECTOR);
-  pbs->bpb.bpb16.sectorsPerCluster = m_sectorsPerCluster;
-  setLe16(pbs->bpb.bpb16.reservedSectorCount, m_reservedSectorCount);
-  pbs->bpb.bpb16.fatCount = 2;
-  // skip rootDirEntryCount
-  // skip totalSectors16
-  pbs->bpb.bpb16.mediaType = 0XF8;
-  // skip sectorsPerFat16
-  // skip sectorsPerTrack
-  // skip headCount
-  setLe32(pbs->bpb.bpb16.hidddenSectors, m_relativeSectors);
-  setLe32(pbs->bpb.bpb16.totalSectors32, m_totalSectors);
-  // skip rest of bpb
-  setLe16(pbs->signature, PBR_SIGNATURE);
-}
-//------------------------------------------------------------------------------
-bool FatFormatter::makeFat16() {
-  uint32_t nc;
-  uint32_t r;
-  PbsFat_t* pbs = reinterpret_cast<PbsFat_t*>(m_secBuf);
-
-  for (m_dataStart = 2*BU16; ; m_dataStart += BU16) {
-    nc = (m_sectorCount - m_dataStart)/m_sectorsPerCluster;
-    m_fatSize = (nc + 2 + (BYTES_PER_SECTOR/2) - 1)/(BYTES_PER_SECTOR/2);
-    r = BU16 + 1 + 2*m_fatSize + FAT16_ROOT_SECTOR_COUNT;
-    if (m_dataStart >= r) {
-      m_relativeSectors = m_dataStart - r + BU16;
-      break;
-    }
-  }
-  // check valid cluster count for FAT16 volume
-  if (nc < 4085 || nc >= 65525) {
-    writeMsg("Bad cluster count\r\n");
-    return false;
-  }
-  m_reservedSectorCount = 1;
-  m_fatStart = m_relativeSectors + m_reservedSectorCount;
-  m_totalSectors = nc*m_sectorsPerCluster
-                   + 2*m_fatSize + m_reservedSectorCount + 32;
-  if (m_totalSectors < 65536) {
-    m_partType = 0X04;
-  } else {
-    m_partType = 0X06;
-  }
-  // write MBR
-  if (!writeMbr()) {
-    return false;
-  }
-  initPbs();
-  setLe16(pbs->bpb.bpb16.rootDirEntryCount, FAT16_ROOT_ENTRY_COUNT);
-  setLe16(pbs->bpb.bpb16.sectorsPerFat16, m_fatSize);
-  pbs->bpb.bpb16.physicalDriveNumber = 0X80;
-  pbs->bpb.bpb16.extSignature = EXTENDED_BOOT_SIGNATURE;
-  setLe32(pbs->bpb.bpb16.volumeSerialNumber, 1234567);
-  for (size_t i = 0; i < sizeof(pbs->bpb.bpb16.volumeLabel); i++) {
-    pbs->bpb.bpb16.volumeLabel[i] = ' ';
-  }
-  pbs->bpb.bpb16.volumeType[0] = 'F';
-  pbs->bpb.bpb16.volumeType[1] = 'A';
-  pbs->bpb.bpb16.volumeType[2] = 'T';
-  pbs->bpb.bpb16.volumeType[3] = '1';
-  pbs->bpb.bpb16.volumeType[4] = '6';
-  if (!m_dev->writeSector(m_relativeSectors, m_secBuf)) {
-    return false;
-  }
-  return initFatDir(16, m_dataStart - m_fatStart);
-}
-//------------------------------------------------------------------------------
-bool FatFormatter::makeFat32() {
-  uint32_t nc;
-  uint32_t r;
-  PbsFat_t* pbs = reinterpret_cast<PbsFat_t*>(m_secBuf);
-  FsInfo_t* fsi = reinterpret_cast<FsInfo_t*>(m_secBuf);
-
-  m_relativeSectors = BU32;
-  for (m_dataStart = 2*BU32; ; m_dataStart += BU32) {
-    nc = (m_sectorCount - m_dataStart)/m_sectorsPerCluster;
-    m_fatSize = (nc + 2 + (BYTES_PER_SECTOR/4) - 1)/(BYTES_PER_SECTOR/4);
-    r = m_relativeSectors + 9 + 2*m_fatSize;
-    if (m_dataStart >= r) {
-      break;
-    }
-  }
-  // error if too few clusters in FAT32 volume
-  if (nc < 65525) {
-    writeMsg("Bad cluster count\r\n");
-    return false;
-  }
-  m_reservedSectorCount = m_dataStart - m_relativeSectors - 2*m_fatSize;
-  m_fatStart = m_relativeSectors + m_reservedSectorCount;
-  m_totalSectors = nc*m_sectorsPerCluster + m_dataStart - m_relativeSectors;
-  // type depends on address of end sector
-  // max CHS has lba = 16450560 = 1024*255*63
-  if ((m_relativeSectors + m_totalSectors) <= 16450560) {
-    // FAT32 with CHS and LBA
-    m_partType = 0X0B;
-  } else {
-    // FAT32 with only LBA
-    m_partType = 0X0C;
-  }
-  if (!writeMbr()) {
-    return false;
-  }
-  initPbs();
-  setLe32(pbs->bpb.bpb32.sectorsPerFat32, m_fatSize);
-  setLe32(pbs->bpb.bpb32.fat32RootCluster, 2);
-  setLe16(pbs->bpb.bpb32.fat32FSInfoSector, 1);
-  setLe16(pbs->bpb.bpb32.fat32BackBootSector, 6);
-  pbs->bpb.bpb32.physicalDriveNumber = 0X80;
-  pbs->bpb.bpb32.extSignature = EXTENDED_BOOT_SIGNATURE;
-  setLe32(pbs->bpb.bpb32.volumeSerialNumber, 1234567);
-  for (size_t i = 0; i < sizeof(pbs->bpb.bpb32.volumeLabel); i++) {
-    pbs->bpb.bpb32.volumeLabel[i] = ' ';
-  }
-  pbs->bpb.bpb32.volumeType[0] = 'F';
-  pbs->bpb.bpb32.volumeType[1] = 'A';
-  pbs->bpb.bpb32.volumeType[2] = 'T';
-  pbs->bpb.bpb32.volumeType[3] = '3';
-  pbs->bpb.bpb32.volumeType[4] = '2';
-  if (!m_dev->writeSector(m_relativeSectors, m_secBuf)  ||
-      !m_dev->writeSector(m_relativeSectors + 6, m_secBuf)) {
-    return false;
-  }
-  // write extra boot area and backup
-  memset(m_secBuf, 0 , BYTES_PER_SECTOR);
-  setLe32(fsi->trailSignature, FSINFO_TRAIL_SIGNATURE);
-  if (!m_dev->writeSector(m_relativeSectors + 2, m_secBuf)  ||
-      !m_dev->writeSector(m_relativeSectors + 8, m_secBuf)) {
-    return false;
-  }
-  // write FSINFO sector and backup
-  setLe32(fsi->leadSignature, FSINFO_LEAD_SIGNATURE);
-  setLe32(fsi->structSignature, FSINFO_STRUCT_SIGNATURE);
-  setLe32(fsi->freeCount, 0XFFFFFFFF);
-  setLe32(fsi->nextFree, 0XFFFFFFFF);
-  if (!m_dev->writeSector(m_relativeSectors + 1, m_secBuf)  ||
-      !m_dev->writeSector(m_relativeSectors + 7, m_secBuf)) {
-    return false;
-  }
-  return initFatDir(32, 2*m_fatSize + m_sectorsPerCluster);
-}
-//------------------------------------------------------------------------------
-bool FatFormatter::writeMbr() {
-  memset(m_secBuf, 0, BYTES_PER_SECTOR);
-  MbrSector_t* mbr = reinterpret_cast<MbrSector_t*>(m_secBuf);
-
-#if USE_LBA_TO_CHS
-  lbaToMbrChs(mbr->part->beginCHS, m_capacityMB, m_relativeSectors);
-  lbaToMbrChs(mbr->part->endCHS, m_capacityMB,
-              m_relativeSectors + m_totalSectors -1);
-#else  // USE_LBA_TO_CHS
-  mbr->part->beginCHS[0] = 1;
-  mbr->part->beginCHS[1] = 1;
-  mbr->part->beginCHS[2] = 0;
-  mbr->part->endCHS[0] = 0XFE;
-  mbr->part->endCHS[1] = 0XFF;
-  mbr->part->endCHS[2] = 0XFF;
-#endif  // USE_LBA_TO_CHS
-
-  mbr->part->type = m_partType;
-  setLe32(mbr->part->relativeSectors, m_relativeSectors);
-  setLe32(mbr->part->totalSectors, m_totalSectors);
-  setLe16(mbr->signature, MBR_SIGNATURE);
-  return m_dev->writeSector(0, m_secBuf);
-}

lib/SdFat_NoArduino/src/FatLib/FatFormatter.h

@@ -1,66 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FatFormatter_h
-#define FatFormatter_h
-#include "../common/SysCall.h"
-#include "../common/FsBlockDevice.h"
-/**
- * \class FatFormatter
- * \brief Format a FAT volume.
- */
-class FatFormatter {
- public:
-  /**
-   * Format a FAT volume.
-   *
-   * \param[in] dev Block device for volume.
-   * \param[in] secBuffer buffer for writing to volume.
-   * \param[in] pr Print device for progress output.
-   *
-   * \return true for success or false for failure.
-   */
-  bool format(FsBlockDevice* dev, uint8_t* secBuffer, print_t* pr = nullptr);
-
- private:
-  bool initFatDir(uint8_t fatType, uint32_t sectorCount);
-  void initPbs();
-  bool makeFat16();
-  bool makeFat32();
-  bool writeMbr();
-  uint32_t m_capacityMB;
-  uint32_t m_dataStart;
-  uint32_t m_fatSize;
-  uint32_t m_fatStart;
-  uint32_t m_relativeSectors;
-  uint32_t m_sectorCount;
-  uint32_t m_totalSectors;
-  FsBlockDevice* m_dev;
-  print_t* m_pr;
-  uint8_t* m_secBuf;
-  uint16_t m_reservedSectorCount;
-  uint8_t m_partType;
-  uint8_t m_sectorsPerCluster;
-};
-#endif  // FatFormatter_h

lib/SdFat_NoArduino/src/FatLib/FatLib.h

@@ -1,29 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FatLib_h
-#define FatLib_h
-#include "FatVolume.h"
-#include "FatFormatter.h"
-#endif  // FatLib_h

lib/SdFat_NoArduino/src/FatLib/FatName.cpp

@@ -1,356 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "FatName.cpp"
-#include "../common/DebugMacros.h"
-#include "../common/FsUtf.h"
-#include "FatLib.h"
-//------------------------------------------------------------------------------
-uint16_t FatFile::getLfnChar(DirLfn_t* ldir, uint8_t i) {
-  if (i < 5) {
-    return getLe16(ldir->unicode1 + 2*i);
-  } else if (i < 11) {
-    return getLe16(ldir->unicode2 + 2*i - 10);
-  } else if (i < 13) {
-    return getLe16(ldir->unicode3 + 2*i - 22);
-  }
-  DBG_HALT_IF(i >= 13);
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::getName(char* name, size_t size) {
-#if !USE_LONG_FILE_NAMES
-  return getSFN(name, size);
-#elif USE_UTF8_LONG_NAMES
-  return getName8(name, size);
-#else
-  return getName7(name, size);
-#endif  // !USE_LONG_FILE_NAMES
-}
-//------------------------------------------------------------------------------
-size_t FatFile::getName7(char* name, size_t size) {
-  FatFile dir;
-  DirLfn_t* ldir;
-  size_t n = 0;
-  if (!isOpen()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!isLFN()) {
-    return getSFN(name, size);
-  }
-  if (!dir.openCluster(this)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  for (uint8_t order = 1; order <= m_lfnOrd; order++) {
-    ldir = reinterpret_cast<DirLfn_t*>(dir.cacheDir(m_dirIndex - order));
-    if (!ldir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (ldir->attributes != FAT_ATTRIB_LONG_NAME ||
-        order != (ldir->order & 0X1F)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (uint8_t i = 0; i < 13; i++) {
-      uint16_t c = getLfnChar(ldir, i);
-      if (c == 0) {
-        goto done;
-      }
-      if ((n + 1) >= size) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      name[n++] = c >= 0X7F ? '?' : c;
-    }
-  }
- done:
-  name[n] = 0;
-  return n;
-
- fail:
-  name[0] = '\0';
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::getName8(char* name, size_t size) {
-  char* end = name + size;
-  char* str = name;
-  char* ptr;
-  FatFile dir;
-  DirLfn_t* ldir;
-  uint16_t hs = 0;
-  uint32_t cp;
-  if (!isOpen()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-  if (!isLFN()) {
-    return getSFN(name, size);
-  }
-  if (!dir.openCluster(this)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  for (uint8_t order = 1; order <= m_lfnOrd; order++) {
-    ldir = reinterpret_cast<DirLfn_t*>(dir.cacheDir(m_dirIndex - order));
-    if (!ldir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (ldir->attributes != FAT_ATTRIB_LONG_NAME ||
-        order != (ldir->order & 0X1F)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (uint8_t i = 0; i < 13; i++) {
-      uint16_t c = getLfnChar(ldir, i);
-      if (hs) {
-        if (!FsUtf::isLowSurrogate(c)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        cp = FsUtf::u16ToCp(hs, c);
-        hs = 0;
-      } else if (!FsUtf::isSurrogate(c)) {
-        if (c == 0) {
-          goto done;
-        }
-        cp = c;
-      } else if (FsUtf::isHighSurrogate(c)) {
-        hs = c;
-        continue;
-      } else {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      // Save space for zero byte.
-      ptr = FsUtf::cpToMb(cp, str, end - 1);
-      if (!ptr) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      str = ptr;
-    }
-  }
- done:
-  *str = '\0';
-  return str - name;
-
- fail:
-  *name = 0;
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::getSFN(char* name, size_t size) {
-  char c;
-  uint8_t j = 0;
-  uint8_t lcBit = FAT_CASE_LC_BASE;
-  uint8_t* ptr;
-  DirFat_t* dir;
-  if (!isOpen()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (isRoot()) {
-    if (size < 2) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    name[0] = '/';
-    name[1] = '\0';
-    return 1;
-  }
-  // cache entry
-  dir = cacheDirEntry(FsCache::CACHE_FOR_READ);
-  if (!dir) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  ptr = dir->name;
-  // format name
-  for (uint8_t i = 0; i < 12; i++) {
-    if (i == 8) {
-      if (*ptr == ' ') {
-        break;
-      }
-      lcBit = FAT_CASE_LC_EXT;
-      c = '.';
-    } else {
-      c = *ptr++;
-      if ('A' <= c && c <= 'Z' && (lcBit & dir->caseFlags)) {
-        c += 'a' - 'A';
-      }
-      if (c == ' ') {
-        continue;
-      }
-    }
-    if ((j + 1u) >= size) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    name[j++] = c;
-  }
-  name[j] = '\0';
-  return j;
-
- fail:
-  name[0] = '\0';
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::printName(print_t* pr) {
-#if !USE_LONG_FILE_NAMES
-  return printSFN(pr);
-#elif USE_UTF8_LONG_NAMES
-  return printName8(pr);
-# else  // USE_LONG_FILE_NAMES
-  return printName7(pr);
-#endif  // !USE_LONG_FILE_NAMES
-  }
-//------------------------------------------------------------------------------
-size_t FatFile::printName7(print_t* pr) {
-  FatFile dir;
-  DirLfn_t* ldir;
-  size_t n = 0;
-  uint8_t buf[13];
-  uint8_t i;
-
-  if (!isOpen()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-  if (!isLFN()) {
-    return printSFN(pr);
-  }
-  if (!dir.openCluster(this)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  for (uint8_t order = 1; order <= m_lfnOrd; order++) {
-    ldir = reinterpret_cast<DirLfn_t*>(dir.cacheDir(m_dirIndex - order));
-    if (!ldir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (ldir->attributes != FAT_ATTRIB_LONG_NAME ||
-        order != (ldir->order & 0X1F)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (i = 0; i < 13; i++) {
-      uint16_t u = getLfnChar(ldir, i);
-      if (u == 0) {
-        // End of name.
-        break;
-      }
-      buf[i] = u < 0X7F ? u : '?';
-      n++;
-    }
-    pr->write(buf, i);
-  }
-  return n;
-
- fail:
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::printName8(print_t *pr) {
-  FatFile dir;
-  DirLfn_t* ldir;
-  uint16_t hs = 0;
-  uint32_t cp;
-  size_t n = 0;
-  char buf[5];
-  char* end = buf + sizeof(buf);
-  if (!isOpen()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-  }
-  if (!isLFN()) {
-    return printSFN(pr);
-  }
-  if (!dir.openCluster(this)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  for (uint8_t order = 1; order <= m_lfnOrd; order++) {
-    ldir = reinterpret_cast<DirLfn_t*>(dir.cacheDir(m_dirIndex - order));
-    if (!ldir) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (ldir->attributes != FAT_ATTRIB_LONG_NAME ||
-        order != (ldir->order & 0X1F)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    for (uint8_t i = 0; i < 13; i++) {
-      uint16_t c = getLfnChar(ldir, i);;
-      if (hs) {
-        if (!FsUtf::isLowSurrogate(c)) {
-          DBG_FAIL_MACRO;
-          goto fail;
-        }
-        cp = FsUtf::u16ToCp(hs, c);
-        hs = 0;
-      } else if (!FsUtf::isSurrogate(c)) {
-        if (c == 0) {
-          break;
-        }
-        cp = c;
-      } else if (FsUtf::isHighSurrogate(c)) {
-        hs = c;
-        continue;
-      } else {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      char* str = FsUtf::cpToMb(cp, buf, end);
-      if (!str) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      n += pr->write(buf, str - buf);
-    }
-  }
-  return n;
-
- fail:
-  return 0;
-}
-//------------------------------------------------------------------------------
-size_t FatFile::printSFN(print_t* pr) {
-  char name[13];
-  if (!getSFN(name, sizeof(name))) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  return pr->write(name);
-
- fail:
-  return 0;
-}

lib/SdFat_NoArduino/src/FatLib/FatPartition.cpp

@@ -1,489 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include <string.h>
-#define DBG_FILE "FatPartition.cpp"
-#include "../common/DebugMacros.h"
-#include "../common/PartitionTable.h"
-#include "FatLib.h"
-//------------------------------------------------------------------------------
-bool FatPartition::allocateCluster(uint32_t current, uint32_t* next) {
-  uint32_t find;
-  bool setStart;
-  if (m_allocSearchStart < current) {
-    // Try to keep file contiguous. Start just after current cluster.
-    find = current;
-    setStart = false;
-  } else {
-    find = m_allocSearchStart;
-    setStart = true;
-  }
-  while (1) {
-    find++;
-    if (find > m_lastCluster) {
-      if (setStart) {
-        // Can't find space, checked all clusters.
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      find = m_allocSearchStart;
-      setStart = true;
-      continue;
-    }
-    if (find == current) {
-      // Can't find space, already searched clusters after current.
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    uint32_t f;
-    int8_t fg = fatGet(find, &f);
-    if (fg < 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (fg && f == 0) {
-      break;
-    }
-  }
-  if (setStart) {
-    m_allocSearchStart = find;
-  }
-  // Mark end of chain.
-  if (!fatPutEOC(find)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (current) {
-    // Link clusters.
-    if (!fatPut(current, find)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  updateFreeClusterCount(-1);
-  *next = find;
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-// find a contiguous group of clusters
-bool FatPartition::allocContiguous(uint32_t count, uint32_t* firstCluster) {
-  // flag to save place to start next search
-  bool setStart = true;
-  // start of group
-  uint32_t bgnCluster;
-  // end of group
-  uint32_t endCluster;
-  // Start at cluster after last allocated cluster.
-  endCluster = bgnCluster = m_allocSearchStart + 1;
-
-  // search the FAT for free clusters
-  while (1) {
-    if (endCluster > m_lastCluster) {
-      // Can't find space.
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    uint32_t f;
-    int8_t fg = fatGet(endCluster, &f);
-    if (fg < 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (f || fg == 0) {
-      // don't update search start if unallocated clusters before endCluster.
-      if (bgnCluster != endCluster) {
-        setStart = false;
-      }
-      // cluster in use try next cluster as bgnCluster
-      bgnCluster = endCluster + 1;
-    } else if ((endCluster - bgnCluster + 1) == count) {
-      // done - found space
-      break;
-    }
-    endCluster++;
-  }
-  // Remember possible next free cluster.
-  if (setStart) {
-    m_allocSearchStart = endCluster;
-  }
-  // mark end of chain
-  if (!fatPutEOC(endCluster)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  // link clusters
-  while (endCluster > bgnCluster) {
-    if (!fatPut(endCluster - 1, endCluster)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    endCluster--;
-  }
-  // Maintain count of free clusters.
-  updateFreeClusterCount(-count);
-
-  // return first cluster number to caller
-  *firstCluster = bgnCluster;
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-// Fetch a FAT entry - return -1 error, 0 EOC, else 1.
-int8_t FatPartition::fatGet(uint32_t cluster, uint32_t* value) {
-  uint32_t sector;
-  uint32_t next;
-  uint8_t* pc;
-
-  // error if reserved cluster of beyond FAT
-  if (cluster < 2 || cluster > m_lastCluster) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-
-  if (fatType() == 32) {
-    sector = m_fatStartSector + (cluster >> (m_bytesPerSectorShift - 2));
-    pc = fatCachePrepare(sector, FsCache::CACHE_FOR_READ);
-    if (!pc) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    uint16_t offset = (cluster << 2) & m_sectorMask;
-    next = getLe32(pc + offset);
-  } else if (fatType() == 16) {
-    cluster &= 0XFFFF;
-    sector = m_fatStartSector + (cluster >> (m_bytesPerSectorShift - 1) );
-    pc = fatCachePrepare(sector, FsCache::CACHE_FOR_READ);
-    if (!pc) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    uint16_t offset = (cluster << 1) & m_sectorMask;
-    next = getLe16(pc + offset);
-  } else if (FAT12_SUPPORT && fatType() == 12) {
-    uint16_t index = cluster;
-    index += index >> 1;
-    sector = m_fatStartSector + (index >> m_bytesPerSectorShift);
-    pc = fatCachePrepare(sector, FsCache::CACHE_FOR_READ);
-    if (!pc) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    index &= m_sectorMask;
-    uint16_t tmp = pc[index];
-    index++;
-    if (index == m_bytesPerSector) {
-      pc = fatCachePrepare(sector + 1, FsCache::CACHE_FOR_READ);
-      if (!pc) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      index = 0;
-    }
-    tmp |= pc[index] << 8;
-    next = cluster & 1 ? tmp >> 4 : tmp & 0XFFF;
-  } else {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (isEOC(next)) {
-    return 0;
-  }
-  *value = next;
-  return 1;
-
- fail:
-  return -1;
-}
-//------------------------------------------------------------------------------
-// Store a FAT entry
-bool FatPartition::fatPut(uint32_t cluster, uint32_t value) {
-  uint32_t sector;
-  uint8_t* pc;
-
-  // error if reserved cluster of beyond FAT
-  if (cluster < 2 || cluster > m_lastCluster) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-
-  if (fatType() == 32) {
-    sector = m_fatStartSector + (cluster >> (m_bytesPerSectorShift - 2));
-    pc = fatCachePrepare(sector, FsCache::CACHE_FOR_WRITE);
-    if (!pc) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    uint16_t offset = (cluster << 2) & m_sectorMask;
-    setLe32(pc + offset, value);
-    return true;
-  }
-
-  if (fatType() == 16) {
-    cluster &= 0XFFFF;
-    sector = m_fatStartSector + (cluster >> (m_bytesPerSectorShift - 1) );
-    pc = fatCachePrepare(sector, FsCache::CACHE_FOR_WRITE);
-    if (!pc) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    uint16_t offset = (cluster << 1) & m_sectorMask;
-    setLe16(pc + offset, value);
-    return true;
-  }
-
-  if (FAT12_SUPPORT && fatType() == 12) {
-    uint16_t index = cluster;
-    index += index >> 1;
-    sector = m_fatStartSector + (index >> m_bytesPerSectorShift);
-    pc = fatCachePrepare(sector, FsCache::CACHE_FOR_WRITE);
-    if (!pc) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    index &= m_sectorMask;
-    uint8_t tmp = value;
-    if (cluster & 1) {
-      tmp = (pc[index] & 0XF) | tmp << 4;
-    }
-    pc[index] = tmp;
-
-    index++;
-    if (index == m_bytesPerSector) {
-      sector++;
-      index = 0;
-      pc = fatCachePrepare(sector, FsCache::CACHE_FOR_WRITE);
-      if (!pc) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    tmp = value >> 4;
-    if (!(cluster & 1)) {
-      tmp = ((pc[index] & 0XF0)) | tmp >> 4;
-    }
-    pc[index] = tmp;
-    return true;
-  } else {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-// free a cluster chain
-bool FatPartition::freeChain(uint32_t cluster) {
-  uint32_t next;
-  int8_t fg;
-  do {
-    fg = fatGet(cluster, &next);
-    if (fg < 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // free cluster
-    if (!fatPut(cluster, 0)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // Add one to count of free clusters.
-    updateFreeClusterCount(1);
-    if (cluster < m_allocSearchStart) {
-      m_allocSearchStart = cluster - 1;
-    }
-    cluster = next;
-  } while (fg);
-
-  return true;
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-int32_t FatPartition::freeClusterCount() {
-#if MAINTAIN_FREE_CLUSTER_COUNT
-  if (m_freeClusterCount >= 0) {
-    return m_freeClusterCount;
-  }
-#endif  // MAINTAIN_FREE_CLUSTER_COUNT
-  uint32_t free = 0;
-  uint32_t sector;
-  uint32_t todo = m_lastCluster + 1;
-  uint16_t n;
-
-  if (FAT12_SUPPORT && fatType() == 12) {
-    for (unsigned i = 2; i < todo; i++) {
-      uint32_t c;
-      int8_t fg = fatGet(i, &c);
-      if (fg < 0) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      if (fg && c == 0) {
-        free++;
-      }
-    }
-  } else if (fatType() == 16 || fatType() == 32) {
-    sector = m_fatStartSector;
-    while (todo) {
-      uint8_t* pc = fatCachePrepare(sector++, FsCache::CACHE_FOR_READ);
-      if (!pc) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-      n =  fatType() == 16 ? m_bytesPerSector/2 : m_bytesPerSector/4;
-      if (todo < n) {
-        n = todo;
-      }
-      if (fatType() == 16) {
-        uint16_t* p16 = reinterpret_cast<uint16_t*>(pc);
-        for (uint16_t i = 0; i < n; i++) {
-          if (p16[i] == 0) {
-            free++;
-          }
-        }
-      } else {
-        uint32_t* p32 = reinterpret_cast<uint32_t*>(pc);
-        for (uint16_t i = 0; i < n; i++) {
-          if (p32[i] == 0) {
-            free++;
-          }
-        }
-      }
-      todo -= n;
-    }
-  } else {
-    // invalid FAT type
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  setFreeClusterCount(free);
-  return free;
-
- fail:
-  return -1;
-}
-//------------------------------------------------------------------------------
-bool FatPartition::init(FsBlockDevice* dev, uint8_t part, uint32_t volStart) {
-  uint32_t clusterCount;
-  uint32_t totalSectors;
-  m_blockDev = dev;
-  pbs_t* pbs;
-  BpbFat32_t* bpb;
-  uint8_t tmp;
-  m_fatType = 0;
-  m_allocSearchStart = 1;
-  m_cache.init(dev);
-#if USE_SEPARATE_FAT_CACHE
-  m_fatCache.init(dev);
-#endif  // USE_SEPARATE_FAT_CACHE
-  // if part == 0 assume super floppy with FAT boot sector in sector zero
-  // if part > 0 read MBR/GPT partition table
-  if (part) {
-    volStart = partitionTableGetVolumeStartSector(m_cache, part);
-
-    if (!volStart) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  }
-  pbs = reinterpret_cast<pbs_t*>
-        (dataCachePrepare(volStart, FsCache::CACHE_FOR_READ));
-  if (!pbs) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  bpb = reinterpret_cast<BpbFat32_t*>(pbs->bpb);
-  if (bpb->fatCount != 2 || getLe16(bpb->bytesPerSector) != m_bytesPerSector) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_sectorsPerCluster = bpb->sectorsPerCluster;
-  m_clusterSectorMask = m_sectorsPerCluster - 1;
-  // determine shift that is same as multiply by m_sectorsPerCluster
-  m_sectorsPerClusterShift = 0;
-  for (tmp = 1; m_sectorsPerCluster != tmp; tmp <<= 1) {
-    if (tmp == 0) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    m_sectorsPerClusterShift++;
-  }
-  m_sectorsPerFat = getLe16(bpb->sectorsPerFat16);
-  if (m_sectorsPerFat == 0) {
-    m_sectorsPerFat = getLe32(bpb->sectorsPerFat32);
-  }
-  m_fatStartSector = volStart + getLe16(bpb->reservedSectorCount);
-
-  // count for FAT16 zero for FAT32
-  m_rootDirEntryCount = getLe16(bpb->rootDirEntryCount);
-
-  // directory start for FAT16 dataStart for FAT32
-  m_rootDirStart = m_fatStartSector + 2 * m_sectorsPerFat;
-  // data start for FAT16 and FAT32
-  m_dataStartSector = m_rootDirStart +
-    ((FS_DIR_SIZE*m_rootDirEntryCount + m_bytesPerSector - 1)/m_bytesPerSector);
-
-  // total sectors for FAT16 or FAT32
-  totalSectors = getLe16(bpb->totalSectors16);
-  if (totalSectors == 0) {
-    totalSectors = getLe32(bpb->totalSectors32);
-  }
-  // total data sectors
-  clusterCount = totalSectors - (m_dataStartSector - volStart);
-
-  // divide by cluster size to get cluster count
-  clusterCount >>= m_sectorsPerClusterShift;
-  m_lastCluster = clusterCount + 1;
-
-  // Indicate unknown number of free clusters.
-  setFreeClusterCount(-1);
-  // FAT type is determined by cluster count
-  if (clusterCount < 4085) {
-    m_fatType = 12;
-    if (!FAT12_SUPPORT) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-  } else if (clusterCount < 65525) {
-    m_fatType = 16;
-  } else {
-    m_rootDirStart = getLe32(bpb->fat32RootCluster);
-    m_fatType = 32;
-  }
-  m_cache.setMirrorOffset(m_sectorsPerFat);
-#if USE_SEPARATE_FAT_CACHE
-  m_fatCache.setMirrorOffset(m_sectorsPerFat);
-#endif  // USE_SEPARATE_FAT_CACHE
-  return true;
-
- fail:
-  return false;
-}

lib/SdFat_NoArduino/src/FatLib/FatPartition.h

@@ -1,295 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FatPartition_h
-#define FatPartition_h
-/**
- * \file
- * \brief FatPartition class
- */
-#include <stddef.h>
-#include "../common/SysCall.h"
-#include "../common/FsBlockDevice.h"
-#include "../common/FsCache.h"
-#include "../common/FsStructs.h"
-
-/** Type for FAT12 partition */
-const uint8_t FAT_TYPE_FAT12 = 12;
-
-/** Type for FAT12 partition */
-const uint8_t FAT_TYPE_FAT16 = 16;
-
-/** Type for FAT12 partition */
-const uint8_t FAT_TYPE_FAT32 = 32;
-
-//==============================================================================
-/**
- * \class FatPartition
- * \brief Access FAT16 and FAT32 partitions on raw file devices.
- */
-class FatPartition {
- public:
-  /** Create an instance of FatPartition
-   */
-  FatPartition() {}
-
-  /** \return The shift count required to multiply by bytesPerCluster. */
-  uint8_t bytesPerClusterShift() const {
-    return m_sectorsPerClusterShift + m_bytesPerSectorShift;
-  }
-  /** \return Number of bytes in a cluster. */
-  uint16_t bytesPerCluster() const {
-    return m_bytesPerSector << m_sectorsPerClusterShift;
-  }
-  /** \return Number of bytes per sector. */
-  uint16_t bytesPerSector() const {
-    return m_bytesPerSector;
-  }
-  /** \return The shift count required to multiply by bytesPerCluster. */
-  uint8_t bytesPerSectorShift() const {
-    return m_bytesPerSectorShift;
-  }
-  /** \return Number of directory entries per sector. */
-  uint16_t dirEntriesPerCluster() const {
-    return m_sectorsPerCluster*(m_bytesPerSector/FS_DIR_SIZE);
-  }
-  /** \return Mask for sector offset. */
-  uint16_t sectorMask() const {
-    return m_sectorMask;
-  }
-  /** \return The volume's cluster size in sectors. */
-  uint8_t sectorsPerCluster() const {
-    return m_sectorsPerCluster;
-  }
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  uint8_t __attribute__((error("use sectorsPerCluster()"))) blocksPerCluster();
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  /** \return The number of sectors in one FAT. */
-  uint32_t sectorsPerFat()  const {
-    return m_sectorsPerFat;
-  }
-  /** Clear the cache and returns a pointer to the cache.  Not for normal apps.
-   * \return A pointer to the cache buffer or zero if an error occurs.
-   */
-  uint8_t* cacheClear() {
-    return m_cache.clear();
-  }
-  /** \return The total number of clusters in the volume. */
-  uint32_t clusterCount() const {
-    return m_lastCluster - 1;
-  }
-  /** \return The shift count required to multiply by sectorsPerCluster. */
-  uint8_t sectorsPerClusterShift() const {
-    return m_sectorsPerClusterShift;
-  }
-  /** \return The logical sector number for the start of file data. */
-  uint32_t dataStartSector() const {
-    return m_dataStartSector;
-  }
-  /** End access to volume
-   * \return pointer to sector size buffer for format.
-   */
-  uint8_t* end() {
-    m_fatType = 0;
-    return cacheClear();
-  }
-  /** \return The number of File Allocation Tables. */
-  uint8_t fatCount() const {
-    return 2;
-  }
-  /** \return The logical sector number for the start of the first FAT. */
-  uint32_t fatStartSector() const {
-    return m_fatStartSector;
-  }
-  /** \return The FAT type of the volume. Values are 12, 16 or 32. */
-  uint8_t fatType() const {
-    return m_fatType;
-  }
-  /** \return free cluster count or -1 if an error occurs. */
-  int32_t freeClusterCount();
-  /** Initialize a FAT partition.
-   *
-   * \param[in] dev FsBlockDevice for this partition.
-   * \param[in] part The partition to be used.  Legal values for \a part are
-   * 1-4 to use the corresponding partition on a device formatted with
-   * a MBR, Master Boot Record, or zero if the device is formatted as
-   * a super floppy with the FAT boot sector in sector volStart.
-   * \param[in] volStart location of volume if part is zero.
-   *
-   * \return true for success or false for failure.
-   */
-  bool init(FsBlockDevice* dev, uint8_t part = 1, uint32_t volStart = 0);
-  /** \return The number of entries in the root directory for FAT16 volumes. */
-  uint16_t rootDirEntryCount() const {
-    return m_rootDirEntryCount;
-  }
-  /** \return The logical sector number for the start of the root directory
-       on FAT16 volumes or the first cluster number on FAT32 volumes. */
-  uint32_t rootDirStart() const {
-    return m_rootDirStart;
-  }
-  /** \return The number of sectors in the volume */
-  uint32_t volumeSectorCount() const {
-    return sectorsPerCluster()*clusterCount();
-  }
-  /** Debug access to FAT table
-   *
-   * \param[in] n cluster number.
-   * \param[out] v value of entry
-   * \return -1 error, 0 EOC, else 1.
-   */
-  int8_t dbgFat(uint32_t n, uint32_t* v) {
-    return fatGet(n, v);
-  }
-  /**
-   * Check for FsBlockDevice busy.
-   *
-   * \return true if busy else false.
-   */
-  bool isBusy() {return m_blockDev->isBusy();}
-  //----------------------------------------------------------------------------
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  bool dmpDirSector(print_t* pr, uint32_t sector);
-  void dmpFat(print_t* pr, uint32_t start, uint32_t count);
-  bool dmpRootDir(print_t* pr, uint32_t n = 0);
-  void dmpSector(print_t* pr, uint32_t sector, uint8_t bits = 8);
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  //----------------------------------------------------------------------------
- private:
-  /** FatFile allowed access to private members. */
-  friend class FatFile;
-  //----------------------------------------------------------------------------
-  static const uint8_t  m_bytesPerSectorShift = 9;
-  static const uint16_t m_bytesPerSector = 1 << m_bytesPerSectorShift;
-  static const uint16_t m_sectorMask = m_bytesPerSector - 1;
-  //----------------------------------------------------------------------------
-  FsBlockDevice* m_blockDev;            // sector device
-  uint8_t  m_sectorsPerCluster;       // Cluster size in sectors.
-  uint8_t  m_clusterSectorMask;       // Mask to extract sector of cluster.
-  uint8_t  m_sectorsPerClusterShift;  // Cluster count to sector count shift.
-  uint8_t  m_fatType = 0;             // Volume type (12, 16, OR 32).
-  uint16_t m_rootDirEntryCount;       // Number of entries in FAT16 root dir.
-  uint32_t m_allocSearchStart;        // Start cluster for alloc search.
-  uint32_t m_sectorsPerFat;           // FAT size in sectors
-  uint32_t m_dataStartSector;         // First data sector number.
-  uint32_t m_fatStartSector;          // Start sector for first FAT.
-  uint32_t m_lastCluster;             // Last cluster number in FAT.
-  uint32_t m_rootDirStart;            // Start sector FAT16, cluster FAT32.
-  //----------------------------------------------------------------------------
-  // sector I/O functions.
-  bool cacheSafeRead(uint32_t sector, uint8_t* dst) {
-    return m_cache.cacheSafeRead(sector, dst);
-  }
-  bool cacheSafeRead(uint32_t sector, uint8_t* dst, size_t count) {
-    return m_cache.cacheSafeRead(sector, dst, count);
-  }
-  bool cacheSafeWrite(uint32_t sector, const uint8_t* dst) {
-    return m_cache.cacheSafeWrite(sector, dst);
-  }
-  bool cacheSafeWrite(uint32_t sector, const uint8_t* dst, size_t count) {
-    return m_cache.cacheSafeWrite(sector, dst, count);
-  }
-  bool syncDevice() {
-    return m_blockDev->syncDevice();
-  }
-#if MAINTAIN_FREE_CLUSTER_COUNT
-  int32_t  m_freeClusterCount;     // Count of free clusters in volume.
-  void setFreeClusterCount(int32_t value) {
-    m_freeClusterCount = value;
-  }
-  void updateFreeClusterCount(int32_t change) {
-    if (m_freeClusterCount >= 0) {
-      m_freeClusterCount += change;
-    }
-  }
-#else  // MAINTAIN_FREE_CLUSTER_COUNT
-  void setFreeClusterCount(int32_t value) {
-    (void)value;
-  }
-  void updateFreeClusterCount(int32_t change) {
-    (void)change;
-  }
-#endif  // MAINTAIN_FREE_CLUSTER_COUNT
-// sector caches
-  FsCache m_cache;
-  bool cachePrepare(uint32_t sector, uint8_t option) {
-    return m_cache.prepare(sector, option);
-  }
-  FsCache* dataCache() {return &m_cache;}
-#if USE_SEPARATE_FAT_CACHE
-  FsCache m_fatCache;
-  uint8_t* fatCachePrepare(uint32_t sector, uint8_t options) {
-    options |= FsCache::CACHE_STATUS_MIRROR_FAT;
-    return m_fatCache.prepare(sector, options);
-  }
-  bool cacheSync() {
-    return m_cache.sync() && m_fatCache.sync() && syncDevice();
-  }
-#else  // USE_SEPARATE_FAT_CACHE
-  uint8_t* fatCachePrepare(uint32_t sector, uint8_t options) {
-    options |= FsCache::CACHE_STATUS_MIRROR_FAT;
-    return dataCachePrepare(sector, options);
-  }
-  bool cacheSync() {
-    return m_cache.sync() && syncDevice();
-  }
-#endif  // USE_SEPARATE_FAT_CACHE
-  uint8_t* dataCachePrepare(uint32_t sector, uint8_t options) {
-    return m_cache.prepare(sector, options);
-  }
-  void cacheInvalidate() {
-    m_cache.invalidate();
-  }
-  bool cacheSyncData() {
-    return m_cache.sync();
-  }
-  uint8_t* cacheAddress() {
-    return m_cache.cacheBuffer();
-  }
-  uint32_t cacheSectorNumber() {
-    return m_cache.sector();
-  }
-  void cacheDirty() {
-    m_cache.dirty();
-  }
-  //----------------------------------------------------------------------------
-  bool allocateCluster(uint32_t current, uint32_t* next);
-  bool allocContiguous(uint32_t count, uint32_t* firstCluster);
-  uint8_t sectorOfCluster(uint32_t position) const {
-    return (position >> 9) & m_clusterSectorMask;
-  }
-  uint32_t clusterStartSector(uint32_t cluster) const {
-    return m_dataStartSector + ((cluster - 2) << m_sectorsPerClusterShift);
-  }
-  int8_t fatGet(uint32_t cluster, uint32_t* value);
-  bool fatPut(uint32_t cluster, uint32_t value);
-  bool fatPutEOC(uint32_t cluster) {
-    return fatPut(cluster, 0x0FFFFFFF);
-  }
-  bool freeChain(uint32_t cluster);
-  bool isEOC(uint32_t cluster) const {
-    return cluster > m_lastCluster;
-  }
-};
-#endif  // FatPartition

lib/SdFat_NoArduino/src/FatLib/FatVolume.cpp

@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "FatVolume.cpp"
-#include "../common/DebugMacros.h"
-#include "FatLib.h"
-FatVolume* FatVolume::m_cwv = nullptr;
-//------------------------------------------------------------------------------
-bool FatVolume::chdir(const char *path) {
-  FatFile dir;
-  if (!dir.open(vwd(), path, O_RDONLY)) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (!dir.isDir()) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  m_vwd = dir;
-  return true;
-
- fail:
-  return false;
-}

lib/SdFat_NoArduino/src/FatLib/FatVolume.h

@@ -1,359 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FatVolume_h
-#define FatVolume_h
-#include "FatFile.h"
-/**
- * \file
- * \brief FatVolume class
- */
-//------------------------------------------------------------------------------
-/**
- * \class FatVolume
- * \brief Integration class for the FatLib library.
- */
-class FatVolume : public  FatPartition {
- public:
-  /** Get file's user settable attributes.
-   * \param[in] path path to file.
-   * \return user settable file attributes for success else -1.
-   */
-  int attrib(const char* path) {
-    File32 tmpFile;
-    return tmpFile.open(this, path, O_RDONLY) ? tmpFile.attrib() : -1;
-  }
-  /** Set file's user settable attributes.
-   * \param[in] path path to file.
-   * \param[in] bits bit-wise or of selected attributes: FS_ATTRIB_READ_ONLY,
-   *            FS_ATTRIB_HIDDEN, FS_ATTRIB_SYSTEM, FS_ATTRIB_ARCHIVE.
-   *
-   * \return true for success or false for failure.
-   */
-  bool attrib(const char* path, uint8_t bits) {
-    File32 tmpFile;
-    return tmpFile.open(this, path, O_RDONLY) ? tmpFile.attrib(bits) : false;
-  }
-  /**
-   * Initialize an FatVolume object.
-   * \param[in] dev Device block driver.
-   * \param[in] setCwv Set current working volume if true.
-   * \param[in] part partition to initialize.
-   * \param[in] volStart Start sector of volume if part is zero.
-   * \return true for success or false for failure.
-   */
-  bool begin(FsBlockDevice* dev, bool setCwv = true,
-             uint8_t part = 1, uint32_t volStart = 0) {
-    if (!init(dev, part, volStart)) {
-      return false;
-    }
-    if (!chdir()) {
-      return false;
-    }
-    if (setCwv || !m_cwv) {
-      m_cwv = this;
-    }
-    return true;
-  }
-  /** Change global current working volume to this volume. */
-  void chvol() {m_cwv = this;}
-
-  /**
-   * Set volume working directory to root.
-   * \return true for success or false for failure.
-   */
-  bool chdir() {
-    m_vwd.close();
-    return m_vwd.openRoot(this);
-  }
-  /**
-   * Set volume working directory.
-   * \param[in] path Path for volume working directory.
-   * \return true for success or false for failure.
-   */
-  bool chdir(const char *path);
-  //----------------------------------------------------------------------------
-  /**
-   * Test for the existence of a file.
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * \return true if the file exists else false.
-   */
-  bool exists(const char* path) {
-    FatFile tmp;
-    return tmp.open(this, path, O_RDONLY);
-  }
-  //----------------------------------------------------------------------------
-  /** List the directory contents of the volume root directory.
-   *
-   * \param[in] pr Print stream for list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, uint8_t flags = 0) {
-    return m_vwd.ls(pr, flags);
-  }
-  //----------------------------------------------------------------------------
-  /** List the contents of a directory.
-   *
-   * \param[in] pr Print stream for list.
-   *
-   * \param[in] path directory to list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, const char* path, uint8_t flags) {
-    FatFile dir;
-    return dir.open(this, path, O_RDONLY) && dir.ls(pr, flags);
-  }
-  //----------------------------------------------------------------------------
-  /** Make a subdirectory in the volume root directory.
-   *
-   * \param[in] path A path with a valid name for the subdirectory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(const char* path, bool pFlag = true) {
-    FatFile sub;
-    return sub.mkdir(vwd(), path, pFlag);
-  }
-  //----------------------------------------------------------------------------
-  /** open a file
-   *
-   * \param[in] path location of file to be opened.
-   * \param[in] oflag open flags.
-   * \return a File32 object.
-   */
-  File32 open(const char *path, oflag_t oflag = O_RDONLY) {
-    File32 tmpFile;
-    tmpFile.open(this, path, oflag);
-    return tmpFile;
-  }
-  //----------------------------------------------------------------------------
-  /** Remove a file from the volume root directory.
-   *
-   * \param[in] path A path with a valid name for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove(const char* path) {
-    FatFile tmp;
-    return tmp.open(this, path, O_WRONLY) && tmp.remove();
-  }
-  //----------------------------------------------------------------------------
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] oldPath Path name to the file or subdirectory to be renamed.
-   *
-   * \param[in] newPath New path name of the file or subdirectory.
-   *
-   * The \a newPath object must not exist before the rename call.
-   *
-   * The file to be renamed must not be open.  The directory entry may be
-   * moved and file system corruption could occur if the file is accessed by
-   * a file object that was opened before the rename() call.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const char *oldPath, const char *newPath) {
-    FatFile file;
-    return file.open(vwd(), oldPath, O_RDONLY) && file.rename(vwd(), newPath);
-  }
-  //----------------------------------------------------------------------------
-  /** Remove a subdirectory from the volume's working directory.
-   *
-   * \param[in] path A path with a valid name for the subdirectory.
-   *
-   * The subdirectory file will be removed only if it is empty.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir(const char* path) {
-    FatFile sub;
-    return sub.open(this, path, O_RDONLY) && sub.rmdir();
-  }
-  //----------------------------------------------------------------------------
-  /** Truncate a file to a specified length.  The current file position
-   * will be at the new EOF.
-   *
-   * \param[in] path A path with a valid name for the file.
-   * \param[in] length The desired length for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate(const char* path, uint32_t length) {
-    FatFile file;
-    return file.open(this, path, O_WRONLY) && file.truncate(length);
-  }
-#if ENABLE_ARDUINO_SERIAL
-   /** List the directory contents of the root directory to Serial.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(uint8_t flags = 0) {
-    return ls(&Serial, flags);
-  }
-  /** List the directory contents of a directory to Serial.
-   *
-   * \param[in] path directory to list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(const char* path, uint8_t flags = 0) {
-    return ls(&Serial, path, flags);
-  }
-#endif  // ENABLE_ARDUINO_SERIAL
-#if ENABLE_ARDUINO_STRING
-  //----------------------------------------------------------------------------
-  /**
-   * Set volume working directory.
-   * \param[in] path Path for volume working directory.
-   * \return true for success or false for failure.
-   */
-  bool chdir(const String& path) {
-    return chdir(path.c_str());
-  }
-   /**
-   * Test for the existence of a file.
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * \return true if the file exists else false.
-   */
-  bool exists(const String& path) {
-    return exists(path.c_str());
-  }
-  /** Make a subdirectory in the volume root directory.
-   *
-   * \param[in] path A path with a valid name for the subdirectory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(const String& path, bool pFlag = true) {
-    return mkdir(path.c_str(), pFlag);
-  }
-  /** open a file
-   *
-   * \param[in] path location of file to be opened.
-   * \param[in] oflag open flags.
-   * \return a File32 object.
-   */
-  File32 open(const String& path, oflag_t oflag = O_RDONLY) {
-    return open(path.c_str(), oflag );
-  }
-  /** Remove a file from the volume root directory.
-   *
-   * \param[in] path A path with a valid name for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove(const String& path) {
-    return remove(path.c_str());
-  }
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] oldPath Path name to the file or subdirectory to be renamed.
-   *
-   * \param[in] newPath New path name of the file or subdirectory.
-   *
-   * The \a newPath object must not exist before the rename call.
-   *
-   * The file to be renamed must not be open.  The directory entry may be
-   * moved and file system corruption could occur if the file is accessed by
-   * a file object that was opened before the rename() call.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const String& oldPath, const String& newPath) {
-    return rename(oldPath.c_str(), newPath.c_str());
-  }
-  /** Remove a subdirectory from the volume's working directory.
-   *
-   * \param[in] path A path with a valid name for the subdirectory.
-   *
-   * The subdirectory file will be removed only if it is empty.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir(const String& path) {
-    return rmdir(path.c_str());
-  }
-  /** Truncate a file to a specified length.  The current file position
-   * will be at the new EOF.
-   *
-   * \param[in] path A path with a valid name for the file.
-   * \param[in] length The desired length for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate(const String& path, uint32_t length) {
-    return truncate(path.c_str(), length);
-  }
-#endif  // ENABLE_ARDUINO_STRING
-
- private:
-  friend FatFile;
-  static FatVolume* cwv() {return m_cwv;}
-  FatFile* vwd() {return &m_vwd;}
-  static FatVolume* m_cwv;
-  FatFile m_vwd;
-};
-#endif  // FatVolume_h

lib/SdFat_NoArduino/src/FreeStack.cpp

@@ -1,80 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define FREE_STACK_CPP
-#include "FreeStack.h"
-#if defined(HAS_UNUSED_STACK) && HAS_UNUSED_STACK
-//------------------------------------------------------------------------------
-inline char* stackBegin() {
-#if defined(__AVR__)
-  return __brkval ? __brkval : &__bss_end;
-#elif defined(__IMXRT1062__)
-  return reinterpret_cast<char*>(&_ebss);
-#elif defined(__arm__)
-  return reinterpret_cast<char*>(sbrk(0));
-#else  // defined(__AVR__)
-#error "undefined stackBegin"
-#endif  // defined(__AVR__)
-}
-//------------------------------------------------------------------------------
-inline char* stackPointer() {
-#if defined(__AVR__)
-  return reinterpret_cast<char*>(SP);
-#elif defined(__arm__)
-  register uint32_t sp asm("sp");
-  return reinterpret_cast<char*>(sp);
-#else  // defined(__AVR__)
-#error "undefined stackPointer"
-#endif  // defined(__AVR__)
-}
-//------------------------------------------------------------------------------
-/** Stack fill pattern. */
-const char FILL = 0x55;
-void FillStack() {
-  char* p = stackBegin();
-  char* top = stackPointer();
-  while (p < top) {
-    *p++ = FILL;
-  }
-}
-//------------------------------------------------------------------------------
-// May fail if malloc or new is used.
-int UnusedStack() {
-  char* h = stackBegin();
-  char* top = stackPointer();
-  int n;
-
-  for (n = 0; (h + n) < top; n++) {
-    if (h[n] != FILL) {
-      if (n >= 16) {
-        break;
-      }
-      // Attempt to skip used heap.
-      h += n;
-      n = 0;
-    }
-  }
-  return n;
-}
-#endif  // defined(HAS_UNUSED_STACK) && HAS_UNUSED_STACK

lib/SdFat_NoArduino/src/FreeStack.h

@@ -1,94 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FreeStack_h
-#define FreeStack_h
-/**
- * \file
- * \brief FreeStack() function.
- */
-#include <stdint.h>
-#if defined(__AVR__) || defined(DOXYGEN)
-#include <avr/io.h>
-/** Indicate FillStack() and UnusedStack() are available. */
-#define HAS_UNUSED_STACK 1
-/** boundary between stack and heap. */
-extern char *__brkval;
-/** End of bss section.*/
-extern char __bss_end;
-/** Amount of free stack space.
- * \return The number of free bytes.
- */
-inline int FreeStack() {
-  char* sp = reinterpret_cast<char*>(SP);
-  return __brkval ? sp - __brkval : sp - &__bss_end;
-}
-#elif defined(ARDUINO_ARCH_APOLLO3)
-#define HAS_UNUSED_STACK 0
-#elif defined(PLATFORM_ID)  // Particle board
-#include "Arduino.h"
-inline int FreeStack() {
-  return System.freeMemory();
-}
-#elif defined(__IMXRT1062__)
-#define HAS_UNUSED_STACK 1
-extern uint8_t _ebss;
-inline int FreeStack() {
-  register uint32_t sp asm("sp");
-  return reinterpret_cast<char*>(sp) - reinterpret_cast<char*>(&_ebss);
-}
-#elif defined(__arm__)
-#define HAS_UNUSED_STACK 1
-extern "C" char* sbrk(int incr);
-inline int FreeStack() {
-  register uint32_t sp asm("sp");
-  return reinterpret_cast<char*>(sp) - reinterpret_cast<char*>(sbrk(0));
-}
-#else  // defined(__AVR__) || defined(DOXYGEN)
-#ifndef FREE_STACK_CPP
-#warning FreeStack is not defined for this system.
-#endif  // FREE_STACK_CPP
-inline int FreeStack() {
-  return 0;
-}
-#endif  // defined(__AVR__) || defined(DOXYGEN)
-#if defined(HAS_UNUSED_STACK) || defined(DOXYGEN)
-/** Fill stack with 0x55 pattern */
-void FillStack();
-/**
- * Determine the amount of unused stack.
- *
- * FillStack() must be called to fill the stack with a 0x55 pattern.
- *
- * UnusedStack() may fail if malloc() or new is use.
- *
- * \return number of bytes with 0x55 pattern.
- */
-int UnusedStack();
-#else  // HAS_UNUSED_STACK
-#define HAS_UNUSED_STACK 0
-inline void FillStack() {}
-inline int UnusedStack() {return 0;}
-#endif  // defined(HAS_UNUSED_STACK)
-#endif  // FreeStack_h

lib/SdFat_NoArduino/src/FsLib/FsFile.cpp

@@ -1,219 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FsLib.h"
-//------------------------------------------------------------------------------
-FsBaseFile::FsBaseFile(const FsBaseFile& from) {
-  m_fFile = nullptr;
-  m_xFile = nullptr;
-  if (from.m_fFile) {
-    m_fFile = new (m_fileMem) FatFile;
-    *m_fFile = *from.m_fFile;
-  } else if (from.m_xFile) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    *m_xFile = *from.m_xFile;
-  }
-}
-//------------------------------------------------------------------------------
-FsBaseFile& FsBaseFile::operator=(const FsBaseFile& from) {
-  if (this == &from) {return *this;}
-  close();
-  if (from.m_fFile) {
-    m_fFile = new (m_fileMem) FatFile;
-    *m_fFile = *from.m_fFile;
-  } else if (from.m_xFile) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    *m_xFile = *from.m_xFile;
-  }
-  return *this;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::close() {
-  bool rtn = m_fFile ? m_fFile->close() : m_xFile ? m_xFile->close() : true;
-  m_fFile = nullptr;
-  m_xFile = nullptr;
-  return rtn;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::mkdir(FsBaseFile* dir, const char* path, bool pFlag) {
-  close();
-  if (dir->m_fFile) {
-    m_fFile = new (m_fileMem) FatFile;
-    if (m_fFile->mkdir(dir->m_fFile, path, pFlag)) {
-      return true;
-    }
-    m_fFile = nullptr;
-  } else if (dir->m_xFile) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    if (m_xFile->mkdir(dir->m_xFile, path, pFlag)) {
-      return true;
-    }
-    m_xFile = nullptr;
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::open(FsVolume* vol, const char* path, oflag_t oflag) {
-  if (!vol) {
-    return false;
-  }
-  close();
-  if (vol->m_fVol) {
-    m_fFile = new (m_fileMem) FatFile;
-    if (m_fFile && m_fFile->open(vol->m_fVol, path, oflag)) {
-      return true;
-    }
-    m_fFile = nullptr;
-  } else if (vol->m_xVol) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    if (m_xFile && m_xFile->open(vol->m_xVol, path, oflag)) {
-      return true;
-    }
-    m_xFile = nullptr;
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::open(FsBaseFile* dir, const char* path, oflag_t oflag) {
-  close();
-  if (dir->m_fFile) {
-    m_fFile = new (m_fileMem) FatFile;
-    if (m_fFile->open(dir->m_fFile, path, oflag)) {
-      return true;
-    }
-    m_fFile = nullptr;
-  } else if (dir->m_xFile) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    if (m_xFile->open(dir->m_xFile, path, oflag)) {
-      return true;
-    }
-    m_xFile = nullptr;
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::open(FsBaseFile* dir, uint32_t index, oflag_t oflag) {
-  close();
-  if (dir->m_fFile) {
-    m_fFile = new (m_fileMem) FatFile;
-    if (m_fFile->open(dir->m_fFile, index, oflag)) {
-      return true;
-    }
-    m_fFile = nullptr;
-  } else if (dir->m_xFile) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    if (m_xFile->open(dir->m_xFile, index, oflag)) {
-      return true;
-    }
-    m_xFile = nullptr;
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::openCwd() {
-  close();
-  if (FsVolume::m_cwv && FsVolume::m_cwv->m_fVol) {
-    m_fFile = new (m_fileMem) FatFile;
-    if (m_fFile->openCwd()) {
-      return true;
-    }
-    m_fFile = nullptr;
-  } else if (FsVolume::m_cwv && FsVolume::m_cwv->m_xVol) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    if (m_xFile->openCwd()) {
-      return true;
-    }
-    m_xFile = nullptr;
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::openNext(FsBaseFile* dir, oflag_t oflag) {
-  close();
-  if (dir->m_fFile) {
-    m_fFile = new (m_fileMem) FatFile;
-    if (m_fFile->openNext(dir->m_fFile, oflag)) {
-      return true;
-    }
-    m_fFile = nullptr;
-  } else if (dir->m_xFile) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    if (m_xFile->openNext(dir->m_xFile, oflag)) {
-      return true;
-    }
-    m_xFile = nullptr;
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::openRoot(FsVolume* vol) {
-  if (!vol) {
-    return false;
-  }
-  close();
-  if (vol->m_fVol) {
-    m_fFile = new (m_fileMem) FatFile;
-    if (m_fFile && m_fFile->openRoot(vol->m_fVol)) {
-      return true;
-    }
-    m_fFile = nullptr;
-  } else if (vol->m_xVol) {
-    m_xFile = new (m_fileMem) ExFatFile;
-    if (m_xFile && m_xFile->openRoot(vol->m_xVol)) {
-      return true;
-    }
-    m_xFile = nullptr;
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::remove() {
-  if (m_fFile) {
-    if (m_fFile->remove()) {
-      m_fFile = nullptr;
-      return true;
-    }
-  } else if (m_xFile) {
-    if (m_xFile->remove()) {
-      m_xFile = nullptr;
-      return true;
-    }
-  }
-  return false;
-}
-//------------------------------------------------------------------------------
-bool FsBaseFile::rmdir() {
-  if (m_fFile) {
-    if (m_fFile->rmdir()) {
-      m_fFile = nullptr;
-      return true;
-    }
-  } else if (m_xFile) {
-    if (m_xFile->rmdir()) {
-      m_xFile = nullptr;
-      return true;
-    }
-  }
-  return false;
-}

lib/SdFat_NoArduino/src/FsLib/FsFile.h

@@ -1,858 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsFile_h
-#define FsFile_h
-/**
- * \file
- * \brief FsBaseFile include file.
- */
-#include "FsNew.h"
-#include "FatLib/FatLib.h"
-#include "ExFatLib/ExFatLib.h"
-/**
- * \class FsBaseFile
- * \brief FsBaseFile class.
- */
-class FsBaseFile {
- public:
-  /** Create an instance. */
-  FsBaseFile() {}
-  /**  Create a file object and open it in the current working directory.
-   *
-   * \param[in] path A path for a file to be opened.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
-   * OR of open flags. see FatFile::open(FatFile*, const char*, uint8_t).
-   */
-  FsBaseFile(const char* path, oflag_t oflag) {
-    open(path, oflag);
-  }
-
-  ~FsBaseFile() {close();}
-  /** Copy constructor.
-   *
-   * \param[in] from Object used to initialize this instance.
-   */
-  FsBaseFile(const FsBaseFile& from);
-  /** Copy assignment operator
-   * \param[in] from Object used to initialize this instance.
-   * \return assigned object.
-   */
-  FsBaseFile& operator=(const FsBaseFile& from);
-  /** The parenthesis operator.
-    *
-    * \return true if a file is open.
-    */
-  operator bool() const {return isOpen();}
-  /**
-   * \return user settable file attributes for success else -1.
-   */
-  int attrib() {
-     return m_fFile ? m_fFile->attrib() :
-            m_xFile ? m_xFile->attrib() : -1;
-  }
-  /** Set file attributes
-   *
-   * \param[in] bits bit-wise or of selected attributes: FS_ATTRIB_READ_ONLY,
-   *            FS_ATTRIB_HIDDEN, FS_ATTRIB_SYSTEM, FS_ATTRIB_ARCHIVE.
-   *
-   * \note attrib() will fail for set read-only if the file is open for write.
-   * \return true for success or false for failure.
-   */
-  bool attrib(uint8_t bits) {
-    return m_fFile ? m_fFile->attrib(bits) :
-           m_xFile ? m_xFile->attrib(bits) : false;
-  }
-  /** \return number of bytes available from the current position to EOF
-   *   or INT_MAX if more than INT_MAX bytes are available.
-   */
-  int available() const {
-    return m_fFile ? m_fFile->available() :
-           m_xFile ? m_xFile->available() : 0;
-  }
-  /** \return The number of bytes available from the current position
-   * to EOF for normal files.  Zero is returned for directory files.
-   */
-  uint64_t available64() const {
-    return m_fFile ? m_fFile->available32() :
-           m_xFile ? m_xFile->available64() : 0;
-  }
-  /** Clear writeError. */
-  void clearWriteError() {
-    if (m_fFile) m_fFile->clearWriteError();
-    if (m_xFile) m_xFile->clearWriteError();
-  }
-  /** Close a file and force cached data and directory information
-   *  to be written to the storage device.
-   *
-   * \return true for success or false for failure.
-   */
-  bool close();
-  /** Check for contiguous file and return its raw sector range.
-   *
-   * \param[out] bgnSector the first sector address for the file.
-   * \param[out] endSector the last  sector address for the file.
-   *
-   * Set contiguous flag for FAT16/FAT32 files.
-   * Parameters may be nullptr.
-   *
-   * \return true for success or false for failure.
-   */
-  bool contiguousRange(uint32_t* bgnSector, uint32_t* endSector) {
-    return m_fFile ? m_fFile->contiguousRange(bgnSector, endSector) :
-           m_xFile ? m_xFile->contiguousRange(bgnSector, endSector) : false;
-  }
-  /** \return The current cluster number for a file or directory. */
-  uint32_t curCluster() const {
-    return m_fFile ? m_fFile->curCluster() :
-           m_xFile ? m_xFile->curCluster() : 0;
-  }
-  /** \return The current position for a file or directory. */
-  uint64_t curPosition() const {
-    return m_fFile ? m_fFile->curPosition() :
-           m_xFile ? m_xFile->curPosition() : 0;
-  }
-  /** \return Directory entry index. */
-  uint32_t dirIndex() const {
-    return m_fFile ? m_fFile->dirIndex() :
-           m_xFile ? m_xFile->dirIndex() : 0;
-  }
-  /** Test for the existence of a file in a directory
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * The calling instance must be an open directory file.
-   *
-   * dirFile.exists("TOFIND.TXT") searches for "TOFIND.TXT" in  the directory
-   * dirFile.
-   *
-   * \return true if the file exists else false.
-   */
-  bool exists(const char* path) {
-    return m_fFile ? m_fFile->exists(path) :
-           m_xFile ? m_xFile->exists(path) : false;
-  }
-  /** get position for streams
-   * \param[out] pos struct to receive position
-   */
-  void fgetpos(fspos_t* pos) const {
-    if (m_fFile) m_fFile->fgetpos(pos);
-    if (m_xFile) m_xFile->fgetpos(pos);
-  }
- /**
-   * Get a string from a file.
-   *
-   * fgets() reads bytes from a file into the array pointed to by \a str, until
-   * \a num - 1 bytes are read, or a delimiter is read and transferred to \a str,
-   * or end-of-file is encountered. The string is then terminated
-   * with a null byte.
-   *
-   * fgets() deletes CR, '\\r', from the string.  This insures only a '\\n'
-   * terminates the string for Windows text files which use CRLF for newline.
-   *
-   * \param[out] str Pointer to the array where the string is stored.
-   * \param[in] num Maximum number of characters to be read
-   * (including the final null byte). Usually the length
-   * of the array \a str is used.
-   * \param[in] delim Optional set of delimiters. The default is "\n".
-   *
-   * \return For success fgets() returns the length of the string in \a str.
-   * If no data is read, fgets() returns zero for EOF or -1 if an error occurred.
-   */
-  int fgets(char* str, int num, char* delim = nullptr) {
-    return m_fFile ? m_fFile->fgets(str, num, delim) :
-           m_xFile ? m_xFile->fgets(str, num, delim) : -1;
-  }
-  /** \return The total number of bytes in a file. */
-  uint64_t fileSize() const {
-    return m_fFile ? m_fFile->fileSize() :
-           m_xFile ? m_xFile->fileSize() : 0;
-  }
-  /** \return Address of first sector or zero for empty file. */
-  uint32_t firstSector() const {
-    return m_fFile ? m_fFile->firstSector() :
-           m_xFile ? m_xFile->firstSector() : 0;
-  }
-  /** Ensure that any bytes written to the file are saved to the SD card. */
-  void flush() {sync();}
-  /** set position for streams
-   * \param[in] pos struct with value for new position
-   */
-  void fsetpos(const fspos_t* pos) {
-    if (m_fFile) m_fFile->fsetpos(pos);
-    if (m_xFile) m_xFile->fsetpos(pos);
-  }
-  /** Get a file's access date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime Packed time for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getAccessDateTime(uint16_t* pdate, uint16_t* ptime) {
-    return m_fFile ? m_fFile->getAccessDateTime(pdate, ptime) :
-           m_xFile ? m_xFile->getAccessDateTime(pdate, ptime) : false;
-  }
-  /** Get a file's create date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime Packed time for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getCreateDateTime(uint16_t* pdate, uint16_t* ptime) {
-    return m_fFile ? m_fFile->getCreateDateTime(pdate, ptime) :
-           m_xFile ? m_xFile->getCreateDateTime(pdate, ptime) : false;
-  }
-  /** \return All error bits. */
-  uint8_t getError() const {
-    return m_fFile ? m_fFile->getError() :
-           m_xFile ? m_xFile->getError() : 0XFF;
-  }
-  /** Get a file's Modify date and time.
-   *
-   * \param[out] pdate Packed date for directory entry.
-   * \param[out] ptime Packed time for directory entry.
-   *
-   * \return true for success or false for failure.
-   */
-  bool getModifyDateTime(uint16_t* pdate, uint16_t* ptime) {
-    return m_fFile ? m_fFile->getModifyDateTime(pdate, ptime) :
-           m_xFile ? m_xFile->getModifyDateTime(pdate, ptime) : false;
-  }
-  /**
-   * Get a file's name followed by a zero byte.
-   *
-   * \param[out] name An array of characters for the file's name.
-   * \param[in] len The size of the array in bytes. The array
-   *             must be at least 13 bytes long.  The file's name will be
-   *             truncated if the file's name is too long.
-   * \return The length of the returned string.
-   */
-  size_t getName(char* name, size_t len) {
-    *name = 0;
-    return m_fFile ? m_fFile->getName(name, len) :
-           m_xFile ? m_xFile->getName(name, len) : 0;
-  }
-
-  /** \return value of writeError */
-  bool getWriteError() const {
-    return m_fFile ? m_fFile->getWriteError() :
-           m_xFile ? m_xFile->getWriteError() : true;
-  }
-  /**
-   * Check for FsBlockDevice busy.
-   *
-   * \return true if busy else false.
-   */
-  bool isBusy() {
-    return m_fFile ? m_fFile->isBusy() :
-           m_xFile ? m_xFile->isBusy() : true;
-  }
-  /** \return True if the file is contiguous. */
-  bool isContiguous() const {
-#if USE_FAT_FILE_FLAG_CONTIGUOUS
-    return m_fFile ? m_fFile->isContiguous() :
-           m_xFile ? m_xFile->isContiguous() : false;
-#else  // USE_FAT_FILE_FLAG_CONTIGUOUS
-    return m_xFile ? m_xFile->isContiguous() : false;
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-  }
-  /** \return True if this is a directory else false. */
-  bool isDir() const {
-    return m_fFile ? m_fFile->isDir() :
-           m_xFile ? m_xFile->isDir() : false;
-  }
-  /** This function reports if the current file is a directory or not.
-   * \return true if the file is a directory.
-   */
-  bool isDirectory() const {return isDir();}
-  /** \return True if this is a normal file. */
-  bool isFile() const {
-    return m_fFile ? m_fFile->isFile() :
-           m_xFile ? m_xFile->isFile() : false;
-  }
-  /** \return True if this is a normal file or sub-directory. */
-  bool isFileOrSubDir() const {
-    return m_fFile ? m_fFile->isFileOrSubDir() :
-           m_xFile ? m_xFile->isFileOrSubDir() : false;
-  }
-  /** \return True if this is a hidden file else false. */
-  bool isHidden() const {
-    return m_fFile ? m_fFile->isHidden() :
-           m_xFile ? m_xFile->isHidden() : false;
-  }
-  /** \return True if this is an open file/directory else false. */
-  bool isOpen() const {return m_fFile || m_xFile;}
-  /** \return True file is readable. */
-  bool isReadable() const {
-    return m_fFile ? m_fFile->isReadable() :
-           m_xFile ? m_xFile->isReadable() : false;
-    }
-  /** \return True if file is read-only */
-  bool isReadOnly() const {
-    return m_fFile ? m_fFile->isReadOnly() :
-           m_xFile ? m_xFile->isReadOnly() : false;
-  }
-  /** \return True if this is a sub-directory file else false. */
-  bool isSubDir() const {
-    return m_fFile ? m_fFile->isSubDir() :
-           m_xFile ? m_xFile->isSubDir() : false;
-  }
-  /** \return True file is writable. */
-  bool isWritable() const {
-    return m_fFile ? m_fFile->isWritable() :
-           m_xFile ? m_xFile->isWritable() : false;
-  }
-#if ENABLE_ARDUINO_SERIAL
-  /** List directory contents.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   */
-  bool ls(uint8_t flags) {
-    return ls(&Serial, flags);
-  }
-  /** List directory contents. */
-  bool ls() {
-    return ls(&Serial);
-  }
-#endif  // ENABLE_ARDUINO_SERIAL
-  /** List directory contents.
-   *
-   * \param[in] pr Print object.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr) {
-    return m_fFile ? m_fFile->ls(pr) :
-           m_xFile ? m_xFile->ls(pr) : false;
-  }
-  /** List directory contents.
-   *
-   * \param[in] pr Print object.
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, uint8_t flags) {
-    return m_fFile ? m_fFile->ls(pr, flags) :
-           m_xFile ? m_xFile->ls(pr, flags) : false;
-  }
-  /** Make a new directory.
-   *
-   * \param[in] dir An open FatFile instance for the directory that will
-   *                   contain the new directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the new directory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(FsBaseFile* dir, const char* path, bool pFlag = true);
-  /** Open a file or directory by name.
-   *
-   * \param[in] dir An open file instance for the directory containing
-   *                    the file to be opened.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a
-   *                  bitwise-inclusive OR of flags from the following list
-   *
-   * O_RDONLY - Open for reading only..
-   *
-   * O_READ - Same as O_RDONLY.
-   *
-   * O_WRONLY - Open for writing only.
-   *
-   * O_WRITE - Same as O_WRONLY.
-   *
-   * O_RDWR - Open for reading and writing.
-   *
-   * O_APPEND - If set, the file offset shall be set to the end of the
-   * file prior to each write.
-   *
-   * O_AT_END - Set the initial position at the end of the file.
-   *
-   * O_CREAT - If the file exists, this flag has no effect except as noted
-   * under O_EXCL below. Otherwise, the file shall be created
-   *
-   * O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file exists.
-   *
-   * O_TRUNC - If the file exists and is a regular file, and the file is
-   * successfully opened and is not read only, its length shall be truncated to 0.
-   *
-   * WARNING: A given file must not be opened by more than one file object
-   * or file corruption may occur.
-   *
-   * \note Directory files must be opened read only.  Write and truncation is
-   * not allowed for directory files.
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(FsBaseFile* dir, const char* path, oflag_t oflag = O_RDONLY);
-  /** Open a file by index.
-   *
-   * \param[in] dir An open FsFile instance for the directory.
-   *
-   * \param[in] index The \a index of the directory entry for the file to be
-   * opened.  The value for \a index is (directory file position)/32.
-   *
-   * \param[in] oflag bitwise-inclusive OR of open flags.
-   *            See see FsFile::open(FsFile*, const char*, uint8_t).
-   *
-   * See open() by path for definition of flags.
-   * \return true for success or false for failure.
-   */
-  bool open(FsBaseFile* dir, uint32_t index, oflag_t oflag = O_RDONLY);
-  /** Open a file or directory by name.
-   *
-   * \param[in] vol Volume where the file is located.
-   *
-   * \param[in] path A path for a file to be opened.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a
-   *                  bitwise-inclusive OR of open flags.
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(FsVolume* vol, const char* path, oflag_t oflag = O_RDONLY);
-  /** Open a file or directory by name.
-   *
-   * \param[in] path A path for a file to be opened.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a
-   *                  bitwise-inclusive OR of open flags.
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(const char* path, oflag_t oflag = O_RDONLY) {
-    return FsVolume::m_cwv && open(FsVolume::m_cwv, path, oflag);
-  }
-   /** Open a file or directory by index in the current working directory.
-   *
-   * \param[in] index The \a index of the directory entry for the file to be
-   * opened.  The value for \a index is (directory file position)/32.
-   *
-   * \param[in] oflag Values for \a oflag are constructed by a
-   *                  bitwise-inclusive OR of open flags.
-   *
-   * \return true for success or false for failure.
-   */
-  bool open(uint32_t index, oflag_t oflag = O_RDONLY) {
-    FsBaseFile cwd;
-    return cwd.openCwd() && open(&cwd, index, oflag);
-  }
-  /** Open the current working directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool openCwd();
-  /** Opens the next file or folder in a directory.
-   * \param[in] dir directory containing files.
-   * \param[in] oflag open flags.
-   * \return a file object.
-   */
-  bool openNext(FsBaseFile* dir, oflag_t oflag = O_RDONLY);
-  /** Open a volume's root directory.
-   *
-   * \param[in] vol The SdFs volume containing the root directory to be opened.
-   *
-   * \return true for success or false for failure.
-   */
-  bool openRoot(FsVolume* vol);
-  /** \return the current file position. */
-  uint64_t position() const {return curPosition();}
-  /** Return the next available byte without consuming it.
-   *
-   * \return The byte if no error and not at eof else -1;
-   */
-  int peek() {
-    return m_fFile ? m_fFile->peek() :
-           m_xFile ? m_xFile->peek() : -1;
-  }
-  /** Allocate contiguous clusters to an empty file.
-   *
-   * The file must be empty with no clusters allocated.
-   *
-   * The file will contain uninitialized data for FAT16/FAT32 files.
-   * exFAT files will have zero validLength and dataLength will equal
-   * the requested length.
-   *
-   * \param[in] length size of the file in bytes.
-   * \return true for success or false for failure.
-   */
-  bool preAllocate(uint64_t length) {
-    return m_fFile ? length < (1ULL << 32) && m_fFile->preAllocate(length) :
-           m_xFile ? m_xFile->preAllocate(length) : false;
-  }
-  /** Print a file's access date and time
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printAccessDateTime(print_t* pr) {
-    return m_fFile ? m_fFile->printAccessDateTime(pr) :
-           m_xFile ? m_xFile->printAccessDateTime(pr) : 0;
-  }
-  /** Print a file's creation date and time
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printCreateDateTime(print_t* pr) {
-    return m_fFile ? m_fFile->printCreateDateTime(pr) :
-           m_xFile ? m_xFile->printCreateDateTime(pr) : 0;
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  size_t printField(double value, char term, uint8_t prec = 2) {
-    return m_fFile ? m_fFile->printField(value, term, prec) :
-           m_xFile ? m_xFile->printField(value, term, prec) : 0;
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  size_t printField(float value, char term, uint8_t prec = 2) {
-     return printField(static_cast<double>(value), term, prec);
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  template<typename Type>
-  size_t printField(Type value, char term) {
-    return m_fFile ? m_fFile->printField(value, term) :
-           m_xFile ? m_xFile->printField(value, term) : 0;
-  }
-  /** Print a file's size.
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return The number of characters printed is returned
-   *         for success and zero is returned for failure.
-   */
-  size_t printFileSize(print_t* pr) {
-    return m_fFile ? m_fFile->printFileSize(pr) :
-           m_xFile ? m_xFile->printFileSize(pr) : 0;
-  }
-  /** Print a file's modify date and time
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printModifyDateTime(print_t* pr) {
-    return m_fFile ? m_fFile->printModifyDateTime(pr) :
-           m_xFile ? m_xFile->printModifyDateTime(pr) : 0;
-  }
-  /** Print a file's name
-   *
-   * \param[in] pr Print stream for output.
-   *
-   * \return true for success or false for failure.
-   */
-  size_t printName(print_t* pr) {
-    return m_fFile ? m_fFile->printName(pr) :
-           m_xFile ? m_xFile->printName(pr) : 0;
-  }
-  /** Read the next byte from a file.
-   *
-   * \return For success return the next byte in the file as an int.
-   * If an error occurs or end of file is reached return -1.
-   */
-  int read() {
-    uint8_t b;
-    return read(&b, 1) == 1 ? b : -1;
-  }
-  /** Read data from a file starting at the current position.
-   *
-   * \param[out] buf Pointer to the location that will receive the data.
-   *
-   * \param[in] count Maximum number of bytes to read.
-   *
-   * \return For success read() returns the number of bytes read.
-   * A value less than \a count, including zero, will be returned
-   * if end of file is reached.
-   * If an error occurs, read() returns -1.  Possible errors include
-   * read() called before a file has been opened, corrupt file system
-   * or an I/O error occurred.
-   */
-  int read(void* buf, size_t count) {
-    return m_fFile ? m_fFile->read(buf, count) :
-           m_xFile ? m_xFile->read(buf, count) : -1;
-  }
-  /** Remove a file.
-   *
-   * The directory entry and all data for the file are deleted.
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * file that has a long name. For example if a file has the long name
-   * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove();
-   /** Remove a file.
-   *
-   * The directory entry and all data for the file are deleted.
-   *
-   * \param[in] path Path for the file to be removed.
-   *
-   * Example use: dirFile.remove(filenameToRemove);
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * file that has a long name. For example if a file has the long name
-   * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
-   *
-   * \return true for success or false for failure.
-   */
-  bool remove(const char* path) {
-    return m_fFile ? m_fFile->remove(path) :
-           m_xFile ? m_xFile->remove(path) : false;
-  }
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] newPath New path name for the file/directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const char* newPath) {
-    return m_fFile ? m_fFile->rename(newPath) :
-           m_xFile ? m_xFile->rename(newPath) : false;
-  }
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] dir Directory for the new path.
-   * \param[in] newPath New path name for the file/directory.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(FsBaseFile* dir, const char* newPath) {
-    return m_fFile && dir->m_fFile ? m_fFile->rename(dir->m_fFile, newPath) :
-           m_xFile && dir->m_xFile ? m_xFile->rename(dir->m_xFile, newPath) :
-           false;
-  }
-  /** Set the file's current position to zero. */
-  void rewind() {
-    if (m_fFile) m_fFile->rewind();
-    if (m_xFile) m_xFile->rewind();
-  }
-  /** Rewind a file if it is a directory */
-  void rewindDirectory() {
-    if (isDir()) rewind();
-  }
-  /** Remove a directory file.
-   *
-   * The directory file will be removed only if it is empty and is not the
-   * root directory.  rmdir() follows DOS and Windows and ignores the
-   * read-only attribute for the directory.
-   *
-   * \note This function should not be used to delete the 8.3 version of a
-   * directory that has a long name. For example if a directory has the
-   * long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir();
-  /** Seek to a new position in the file, which must be between
-   * 0 and the size of the file (inclusive).
-   *
-   * \param[in] pos the new file position.
-   * \return true for success or false for failure.
-   */
-  bool seek(uint64_t pos) {return seekSet(pos);}
-  /** Set the files position to current position + \a pos. See seekSet().
-   * \param[in] offset The new position in bytes from the current position.
-   * \return true for success or false for failure.
-   */
-  bool seekCur(int64_t offset) {
-    return seekSet(curPosition() + offset);
-  }
-  /** Set the files position to end-of-file + \a offset. See seekSet().
-   * Can't be used for directory files since file size is not defined.
-   * \param[in] offset The new position in bytes from end-of-file.
-   * \return true for success or false for failure.
-   */
-  bool seekEnd(int64_t offset = 0) {
-    return seekSet(fileSize() + offset);
-  }
-  /** Sets a file's position.
-   *
-   * \param[in] pos The new position in bytes from the beginning of the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool seekSet(uint64_t pos) {
-    return m_fFile ? pos < (1ULL << 32) && m_fFile->seekSet(pos) :
-           m_xFile ? m_xFile->seekSet(pos) : false;
-  }
-  /** \return the file's size. */
-  uint64_t size() const {return fileSize();}
-  /** The sync() call causes all modified data and directory fields
-   * to be written to the storage device.
-   *
-   * \return true for success or false for failure.
-   */
-  bool sync() {
-    return m_fFile ? m_fFile->sync() :
-           m_xFile ? m_xFile->sync() : false;
-  }
-  /** Set a file's timestamps in its directory entry.
-   *
-   * \param[in] flags Values for \a flags are constructed by a bitwise-inclusive
-   * OR of flags from the following list
-   *
-   * T_ACCESS - Set the file's last access date and time.
-   *
-   * T_CREATE - Set the file's creation date and time.
-   *
-   * T_WRITE - Set the file's last write/modification date and time.
-   *
-   * \param[in] year Valid range 1980 - 2107 inclusive.
-   *
-   * \param[in] month Valid range 1 - 12 inclusive.
-   *
-   * \param[in] day Valid range 1 - 31 inclusive.
-   *
-   * \param[in] hour Valid range 0 - 23 inclusive.
-   *
-   * \param[in] minute Valid range 0 - 59 inclusive.
-   *
-   * \param[in] second Valid range 0 - 59 inclusive
-   *
-   * \note It is possible to set an invalid date since there is no check for
-   * the number of days in a month.
-   *
-   * \note
-   * Modify and access timestamps may be overwritten if a date time callback
-   * function has been set by dateTimeCallback().
-   *
-   * \return true for success or false for failure.
-   */
-  bool timestamp(uint8_t flags, uint16_t year, uint8_t month, uint8_t day,
-                 uint8_t hour, uint8_t minute, uint8_t second) {
-    return m_fFile ?
-           m_fFile->timestamp(flags, year, month, day, hour, minute, second) :
-           m_xFile ?
-           m_xFile->timestamp(flags, year, month, day, hour, minute, second) :
-           false;
-  }
-  /** Truncate a file to the current position.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate() {
-    return m_fFile ? m_fFile->truncate() :
-           m_xFile ? m_xFile->truncate() : false;
-  }
-  /** Truncate a file to a specified length.
-   * The current file position will be set to end of file.
-   *
-   * \param[in] length The desired length for the file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool truncate(uint64_t length) {
-    return m_fFile ? length < (1ULL << 32) && m_fFile->truncate(length) :
-           m_xFile ? m_xFile->truncate(length) : false;
-  }
-  /** Write a string to a file. Used by the Arduino Print class.
-   * \param[in] str Pointer to the string.
-   * Use getWriteError to check for errors.
-   * \return count of characters written for success or -1 for failure.
-   */
-  size_t write(const char* str) {
-    return write(str, strlen(str));
-  }
-  /** Write a byte to a file. Required by the Arduino Print class.
-   * \param[in] b the byte to be written.
-   * Use getWriteError to check for errors.
-   * \return 1 for success and 0 for failure.
-   */
-  size_t write(uint8_t b) {return write(&b, 1);}
-  /** Write data to an open file.
-   *
-   * \note Data is moved to the cache but may not be written to the
-   * storage device until sync() is called.
-   *
-   * \param[in] buf Pointer to the location of the data to be written.
-   *
-   * \param[in] count Number of bytes to write.
-   *
-   * \return For success write() returns the number of bytes written, always
-   * \a nbyte.  If an error occurs, write() returns zero and writeError is set.
-   */
-  size_t write(const void* buf, size_t count) {
-    return m_fFile ? m_fFile->write(buf, count) :
-           m_xFile ? m_xFile->write(buf, count) : 0;
-  }
-
- private:
-  newalign_t m_fileMem[FS_ALIGN_DIM(ExFatFile, FatFile)];
-  FatFile*   m_fFile = nullptr;
-  ExFatFile* m_xFile = nullptr;
-};
-/**
- * \class FsFile
- * \brief FsBaseFile file with Arduino Stream.
- */
-class FsFile : public StreamFile<FsBaseFile, uint64_t> {
- public:
-  /** Opens the next file or folder in a directory.
-   *
-   * \param[in] oflag open flags.
-   * \return a FatStream object.
-   */
-  FsFile openNextFile(oflag_t oflag = O_RDONLY) {
-    FsFile tmpFile;
-    tmpFile.openNext(this, oflag);
-    return tmpFile;
-  }
-};
-#endif  // FsFile_h

lib/SdFat_NoArduino/src/FsLib/FsFormatter.h

@@ -1,57 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsFormatter_h
-#define FsFormatter_h
-#include "FatLib/FatLib.h"
-#include "ExFatLib/ExFatLib.h"
-/**
- * \class FsFormatter
- * \brief Format a exFAT/FAT volume.
- */
-class FsFormatter {
- public:
-  /**
-   * Format a FAT volume.
-   *
-   * \param[in] dev Block device for volume.
-   * \param[in] secBuffer buffer for writing to volume.
-   * \param[in] pr Print device for progress output.
-   *
-   * \return true for success or false for failure.
-   */
-  bool format(FsBlockDevice* dev, uint8_t* secBuffer, print_t* pr = nullptr) {
-    uint32_t sectorCount = dev->sectorCount();
-    if (sectorCount == 0) {
-      return false;
-    }
-    return sectorCount <= 67108864 ?
-      m_fFmt.format(dev, secBuffer, pr) :
-      m_xFmt.format(dev, secBuffer, pr);
-  }
- private:
-  FatFormatter m_fFmt;
-  ExFatFormatter m_xFmt;
-};
-#endif  // FsFormatter_h

lib/SdFat_NoArduino/src/FsLib/FsLib.h

@@ -1,34 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsLib_h
-#define FsLib_h
-/**
- * \file
- * \brief FsLib include file.
- */
-#include "FsVolume.h"
-#include "FsFile.h"
-#include "FsFormatter.h"
-#endif  // FsLib_h

lib/SdFat_NoArduino/src/FsLib/FsNew.cpp

@@ -1,29 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FsNew.h"
-void* operator new(size_t size, newalign_t* ptr) {
-  (void)size;
-  return ptr;
-}

lib/SdFat_NoArduino/src/FsLib/FsNew.h

@@ -1,46 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsNew_h
-#define FsNew_h
-#include <stddef.h>
-#include <stdint.h>
-
-/** 32-bit alignment */
-typedef uint32_t newalign_t;
-
-/** Size required for exFAT or FAT class. */
-#define FS_SIZE(etype, ftype) \
-  (sizeof(ftype) < sizeof(etype) ? sizeof(etype) : sizeof(ftype))
-
-/** Dimension of aligned area. */
-#define NEW_ALIGN_DIM(n) \
-  (((size_t)(n) + sizeof(newalign_t) - 1U)/sizeof(newalign_t))
-
-/** Dimension of aligned area for etype or ftype class. */
-#define FS_ALIGN_DIM(etype, ftype) NEW_ALIGN_DIM(FS_SIZE(etype, ftype))
-
-/** Custom new placement operator */
-void* operator new(size_t size, newalign_t* ptr);
-#endif  // FsNew_h

lib/SdFat_NoArduino/src/FsLib/FsVolume.cpp

@@ -1,66 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FsLib.h"
-FsVolume* FsVolume::m_cwv = nullptr;
-//------------------------------------------------------------------------------
-bool FsVolume::begin(FsBlockDevice* blockDev, bool setCwv,
-                     uint8_t part, uint32_t volStart) {
-  m_blockDev = blockDev;
-  m_fVol = nullptr;
-  m_xVol = new (m_volMem) ExFatVolume;
-  if (m_xVol && m_xVol->begin(m_blockDev, false, part, volStart)) {
-    goto done;
-  }
-  m_xVol = nullptr;
-  m_fVol = new (m_volMem) FatVolume;
-  if (m_fVol && m_fVol->begin(m_blockDev, false, part, volStart)) {
-    goto done;
-  }
-  m_fVol = nullptr;
-  return false;
-
- done:
-  if (setCwv || !m_cwv) {
-    m_cwv = this;
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool FsVolume::ls(print_t* pr, const char* path, uint8_t flags) {
-  FsBaseFile dir;
-  return dir.open(this, path, O_RDONLY) && dir.ls(pr, flags);
-}
-//------------------------------------------------------------------------------
-FsFile FsVolume::open(const char *path, oflag_t oflag) {
-  FsFile tmpFile;
-  tmpFile.open(this, path, oflag);
-  return tmpFile;
-}
-#if ENABLE_ARDUINO_STRING
-//------------------------------------------------------------------------------
-FsFile FsVolume::open(const String &path, oflag_t oflag) {
-  return open(path.c_str(), oflag );
-}
-#endif  // ENABLE_ARDUINO_STRING

lib/SdFat_NoArduino/src/FsLib/FsVolume.h

@@ -1,410 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsVolume_h
-#define FsVolume_h
-/**
- * \file
- * \brief FsVolume include file.
- */
-#include "FsNew.h"
-#include "../FatLib/FatLib.h"
-#include "../ExFatLib/ExFatLib.h"
-
-class FsFile;
-/**
- * \class FsVolume
- * \brief FsVolume class.
- */
-class FsVolume {
- public:
-  FsVolume() {}
-
-  ~FsVolume() {end();}
-  /** Get file's user settable attributes.
-   * \param[in] path path to file.
-   * \return user settable file attributes for success else -1.
-   */
-  int attrib(const char* path) {
-    return m_fVol ? m_fVol->attrib(path) :
-           m_xVol ? m_xVol->attrib(path) : -1;
-  }
-  /** Set file's user settable attributes.
-   * \param[in] path path to file.
-   * \param[in] bits bit-wise or of selected attributes: FS_ATTRIB_READ_ONLY,
-   *            FS_ATTRIB_HIDDEN, FS_ATTRIB_SYSTEM, FS_ATTRIB_ARCHIVE.
-   *
-   * \return true for success or false for failure.
-   */
-  bool attrib(const char* path, uint8_t bits) {
-    return m_fVol ? m_fVol->attrib(path, bits) :
-           m_xVol ? m_xVol->attrib(path, bits) : false;
-  }
-  /**
-   * Initialize an FatVolume object.
-   * \param[in] blockDev Device block driver.
-   * \param[in] setCwv Set current working volume if true.
-   * \param[in] part partition to initialize.
-   * \param[in] volStart Start sector of volume if part is zero.
-   * \return true for success or false for failure.
-   */
-  bool begin(FsBlockDevice* blockDev, bool setCwv = true, uint8_t
-             part = 1, uint32_t volStart = 0);
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  uint32_t __attribute__((error("use sectorsPerCluster()"))) blocksPerCluster();
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  /** \return the number of bytes in a cluster. */
-  uint32_t bytesPerCluster() const {
-    return m_fVol ? m_fVol->bytesPerCluster() :
-           m_xVol ? m_xVol->bytesPerCluster() : 0;
-  }
-  /**
-   * Set volume working directory to root.
-   * \return true for success or false for failure.
-   */
-  bool chdir() {
-    return m_fVol ? m_fVol->chdir() :
-           m_xVol ? m_xVol->chdir() : false;
-  }
-  /**
-   * Set volume working directory.
-   * \param[in] path Path for volume working directory.
-   * \return true for success or false for failure.
-   */
-    bool chdir(const char* path) {
-    return m_fVol ? m_fVol->chdir(path) :
-           m_xVol ? m_xVol->chdir(path) : false;
-  }
-  /** Change global working volume to this volume. */
-  void chvol() {m_cwv = this;}
-  /** \return The total number of clusters in the volume. */
-  uint32_t clusterCount() const {
-    return m_fVol ? m_fVol->clusterCount() :
-           m_xVol ? m_xVol->clusterCount() : 0;
-  }
-  /** \return The logical sector number for the start of file data. */
-  uint32_t dataStartSector() const {
-    return m_fVol ? m_fVol->dataStartSector() :
-           m_xVol ? m_xVol->clusterHeapStartSector() : 0;
-  }
-  /** End access to volume
-   * \return pointer to sector size buffer for format.
-   */
-  uint8_t* end() {
-    m_fVol = nullptr;
-    m_xVol = nullptr;
-    static_assert(sizeof(m_volMem) >= 512, "m_volMem too small");
-    return reinterpret_cast<uint8_t*>(m_volMem);
-  }
-  /** Test for the existence of a file in a directory
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * \return true if the file exists else false.
-   */
-  bool exists(const char* path) {
-    return m_fVol ? m_fVol->exists(path) :
-           m_xVol ? m_xVol->exists(path) : false;
-  }
-  /** \return The logical sector number for the start of the first FAT. */
-  uint32_t fatStartSector() const {
-    return m_fVol ? m_fVol->fatStartSector() :
-           m_xVol ? m_xVol->fatStartSector() : 0;
-  }
-  /** \return Partition type, FAT_TYPE_EXFAT, FAT_TYPE_FAT32,
-   *          FAT_TYPE_FAT16, or zero for error.
-   */
-  uint8_t fatType() const {
-    return m_fVol ? m_fVol->fatType() :
-           m_xVol ? m_xVol->fatType() : 0;
-  }
-  /** \return free cluster count or -1 if an error occurs. */
-  int32_t freeClusterCount() const {
-    return m_fVol ? m_fVol->freeClusterCount() :
-           m_xVol ? m_xVol->freeClusterCount() : -1;
-  }
-  /**
-   * Check for device busy.
-   *
-   * \return true if busy else false.
-   */
-  bool isBusy() {
-    return m_fVol ? m_fVol->isBusy() :
-           m_xVol ? m_xVol->isBusy() : false;
-  }
-  /** List directory contents.
-   *
-   * \param[in] pr Print object.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr) {
-    return m_fVol ? m_fVol->ls(pr) :
-           m_xVol ? m_xVol->ls(pr) : false;
-  }
-  /** List directory contents.
-   *
-   * \param[in] pr Print object.
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, uint8_t flags) {
-    return  m_fVol ? m_fVol->ls(pr, flags) :
-            m_xVol ? m_xVol->ls(pr, flags) : false;
-  }
-  /** List the directory contents of a directory.
-   *
-   * \param[in] pr Print stream for list.
-   *
-   * \param[in] path directory to list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(print_t* pr, const char* path, uint8_t flags);
-   /** Make a subdirectory in the volume root directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(const char *path, bool pFlag = true) {
-    return m_fVol ? m_fVol->mkdir(path, pFlag) :
-           m_xVol ? m_xVol->mkdir(path, pFlag) : false;
-  }
-  /** open a file
-   *
-   * \param[in] path location of file to be opened.
-   * \param[in] oflag open flags.
-   * \return a FsBaseFile object.
-   */
-  FsFile open(const char* path, oflag_t oflag = O_RDONLY);
-  /** Remove a file from the volume root directory.
-  *
-  * \param[in] path A path with a valid 8.3 DOS name for the file.
-  *
-   * \return true for success or false for failure.
-  */
-  bool remove(const char *path) {
-    return m_fVol ? m_fVol->remove(path) :
-           m_xVol ? m_xVol->remove(path) : false;
-  }
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] oldPath Path name to the file or subdirectory to be renamed.
-   *
-   * \param[in] newPath New path name of the file or subdirectory.
-   *
-   * The \a newPath object must not exist before the rename call.
-   *
-   * The file to be renamed must not be open.  The directory entry may be
-   * moved and file system corruption could occur if the file is accessed by
-   * a file object that was opened before the rename() call.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const char *oldPath, const char *newPath) {
-    return m_fVol ? m_fVol->rename(oldPath, newPath) :
-           m_xVol ? m_xVol->rename(oldPath, newPath) : false;
-  }
-  /** Remove a subdirectory from the volume's root directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
-   *
-   * The subdirectory file will be removed only if it is empty.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir(const char *path) {
-    return m_fVol ? m_fVol->rmdir(path) :
-           m_xVol ? m_xVol->rmdir(path) : false;
-  }
-  /** \return The volume's cluster size in sectors. */
-  uint32_t sectorsPerCluster() const {
-    return m_fVol ? m_fVol->sectorsPerCluster() :
-           m_xVol ? m_xVol->sectorsPerCluster() : 0;
-  }
-#if ENABLE_ARDUINO_SERIAL
-  /** List directory contents.
-   * \return true for success or false for failure.
-   */
-  bool ls() {
-    return ls(&Serial);
-  }
-  /** List directory contents.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(uint8_t flags) {
-    return ls(&Serial, flags);
-  }
-  /** List the directory contents of a directory to Serial.
-   *
-   * \param[in] path directory to list.
-   *
-   * \param[in] flags The inclusive OR of
-   *
-   * LS_DATE - %Print file modification date
-   *
-   * LS_SIZE - %Print file size.
-   *
-   * LS_R - Recursive list of subdirectories.
-   *
-   * \return true for success or false for failure.
-   *
-   * \return true for success or false for failure.
-   */
-  bool ls(const char* path, uint8_t flags = 0) {
-    return ls(&Serial, path, flags);
-  }
-#endif  // ENABLE_ARDUINO_SERIAL
-#if ENABLE_ARDUINO_STRING
-  /**
-   * Set volume working directory.
-   * \param[in] path Path for volume working directory.
-   * \return true for success or false for failure.
-   */
-  bool chdir(const String& path) {
-    return chdir(path.c_str());
-  }
-  /** Test for the existence of a file in a directory
-   *
-   * \param[in] path Path of the file to be tested for.
-   *
-   * \return true if the file exists else false.
-   */
-  bool exists(const String &path) {
-    return exists(path.c_str());
-  }
-  /** Make a subdirectory in the volume root directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
-   *
-   * \param[in] pFlag Create missing parent directories if true.
-   *
-   * \return true for success or false for failure.
-   */
-  bool mkdir(const String &path, bool pFlag = true) {
-    return mkdir(path.c_str(), pFlag);
-  }
-  /** open a file
-   *
-   * \param[in] path location of file to be opened.
-   * \param[in] oflag open flags.
-   * \return a FsBaseFile object.
-   */
-  FsFile open(const String &path, oflag_t oflag = O_RDONLY);
-  /** Remove a file from the volume root directory.
-  *
-  * \param[in] path A path with a valid 8.3 DOS name for the file.
-  *
-   * \return true for success or false for failure.
-  */
-  bool remove(const String &path) {
-    return remove(path.c_str());
-  }
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] oldPath Path name to the file or subdirectory to be renamed.
-   *
-   * \param[in] newPath New path name of the file or subdirectory.
-   *
-   * The \a newPath object must not exist before the rename call.
-   *
-   * The file to be renamed must not be open.  The directory entry may be
-   * moved and file system corruption could occur if the file is accessed by
-   * a file object that was opened before the rename() call.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rename(const String& oldPath, const String& newPath) {
-    return rename(oldPath.c_str(), newPath.c_str());
-  }
-  /** Remove a subdirectory from the volume's root directory.
-   *
-   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
-   *
-   * The subdirectory file will be removed only if it is empty.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rmdir(const String &path) {
-    return rmdir(path.c_str());
-  }
-  /** Rename a file or subdirectory.
-   *
-   * \param[in] oldPath Path name to the file or subdirectory to be renamed.
-   *
-   * \param[in] newPath New path name of the file or subdirectory.
-   *
-   * The \a newPath object must not exist before the rename call.
-   *
-   * The file to be renamed must not be open.  The directory entry may be
-   * moved and file system corruption could occur if the file is accessed by
-   * a file object that was opened before the rename() call.
-   *
-   * \return true for success or false for failure.
-   */
-#endif  // ENABLE_ARDUINO_STRING
-
- protected:
-  newalign_t   m_volMem[FS_ALIGN_DIM(ExFatVolume, FatVolume)];
-
- private:
-  /** FsBaseFile allowed access to private members. */
-  friend class FsBaseFile;
-  static FsVolume* cwv() {return m_cwv;}
-  FsVolume(const FsVolume& from);
-  FsVolume& operator=(const FsVolume& from);
-
-  static FsVolume* m_cwv;
-  FatVolume*   m_fVol = nullptr;
-  ExFatVolume* m_xVol = nullptr;
-  FsBlockDevice* m_blockDev;
-};
-#endif  // FsVolume_h

lib/SdFat_NoArduino/src/MinimumSerial.cpp

@@ -1,71 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "common/SysCall.h"
-#if defined(UDR0) || defined(DOXYGEN)
-#include "MinimumSerial.h"
-const uint16_t MIN_2X_BAUD = F_CPU/(4*(2*0XFFF + 1)) + 1;
-//------------------------------------------------------------------------------
-int MinimumSerial::available() {
-  return UCSR0A & (1 << RXC0) ? 1 : 0;
-}
-//------------------------------------------------------------------------------
-void MinimumSerial::begin(uint32_t baud) {
-  uint16_t baud_setting;
-  // don't worry, the compiler will squeeze out F_CPU != 16000000UL
-  if ((F_CPU != 16000000UL || baud != 57600) && baud > MIN_2X_BAUD) {
-    // Double the USART Transmission Speed
-    UCSR0A = 1 << U2X0;
-    baud_setting = (F_CPU / 4 / baud - 1) / 2;
-  } else {
-    // hardcoded exception for compatibility with the bootloader shipped
-    // with the Duemilanove and previous boards and the firmware on the 8U2
-    // on the Uno and Mega 2560.
-    UCSR0A = 0;
-    baud_setting = (F_CPU / 8 / baud - 1) / 2;
-  }
-  // assign the baud_setting
-  UBRR0H = baud_setting >> 8;
-  UBRR0L = baud_setting;
-  // enable transmit and receive
-  UCSR0B |= (1 << TXEN0) | (1 << RXEN0);
-}
-//------------------------------------------------------------------------------
-void MinimumSerial::flush() {
-  while (((1 << UDRIE0) & UCSR0B) || !(UCSR0A & (1 << UDRE0))) {}
-}
-//------------------------------------------------------------------------------
-int MinimumSerial::read() {
-  if (UCSR0A & (1 << RXC0)) {
-    return UDR0;
-  }
-  return -1;
-}
-//------------------------------------------------------------------------------
-size_t MinimumSerial::write(uint8_t b) {
-  while (((1 << UDRIE0) & UCSR0B) || !(UCSR0A & (1 << UDRE0))) {}
-  UDR0 = b;
-  return 1;
-}
-#endif  //  defined(UDR0) || defined(DOXYGEN)

lib/SdFat_NoArduino/src/MinimumSerial.h

@@ -1,67 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
- /**
- * \file
- * \brief Minimal AVR Serial driver.
- */
-#ifndef MinimumSerial_h
-#define MinimumSerial_h
-#include "common/SysCall.h"
-//==============================================================================
-/**
- * \class MinimumSerial
- * \brief mini serial class for the %SdFat library.
- */
-class MinimumSerial : public print_t {
- public:
-  /** \return true for hardware serial */
-  operator bool() {return true;}
-  /**
-   * \return one if data is available.
-   */
-  int available();
-  /**
-   * Set baud rate for serial port zero and enable in non interrupt mode.
-   * Do not call this function if you use another serial library.
-   * \param[in] baud rate
-   */
-  void begin(uint32_t baud);
-  /** Wait for write done. */
-  void flush();
-  /**
-   *  Unbuffered read
-   *  \return -1 if no character is available or an available character.
-   */
-  int read();
-  /**
-   * Unbuffered write
-   *
-   * \param[in] b byte to write.
-   * \return 1
-   */
-  size_t write(uint8_t b);
-  using print_t::write;
-};
-#endif  // MinimumSerial_h

lib/SdFat_NoArduino/src/RingBuf.h

@@ -1,366 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef RingBuf_h
-#define RingBuf_h
-/**
- * \file
- * \brief Ring buffer for data loggers.
- */
-#include "common/SysCall.h"
-#include "common/FmtNumber.h"
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-//  Teensy 3.5/3.6 has hard fault at 0x20000000 for unaligned memcpy.
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-inline bool is_aligned(const void* ptr, uintptr_t alignment) {
-    auto iptr = reinterpret_cast<uintptr_t>(ptr);
-    return !(iptr % alignment);
-}
-inline void memcpyBuf(void* dst, const void* src, size_t len) {
-  const uint8_t* b = reinterpret_cast<const uint8_t*>(0X20000000UL);
-  uint8_t* d = reinterpret_cast<uint8_t*>(dst);
-  const uint8_t *s = reinterpret_cast<const uint8_t*>(src);
-  if ((is_aligned(d, 4) && is_aligned(s, 4) && (len & 3) == 0) ||
-    !((d < b && b <= (d + len)) || (s < b && b <= (s + len)))) {
-    memcpy(dst, src, len);
-  } else {
-    while (len--) {
-      *d++ = *s++;
-    }
-  }
-}
-#else  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-inline void memcpyBuf(void* dst, const void* src, size_t len) {
-  memcpy(dst, src, len);
-}
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-/**
- * \class RingBuf
- * \brief Ring buffer for data loggers.
- *
- * This ring buffer may be used in ISRs.  bytesFreeIsr(), bytesUsedIsr(),
- * memcopyIn(), and memcopyOut() are ISR callable.  For ISR use call
- * memcopyIn() in the ISR and use writeOut() in non-interrupt code
- * to write data to a file. readIn() and memcopyOut can be use in a
- * similar way to provide file data to an ISR.
- *
- * Print into a RingBuf in an ISR should also work but has not been verified.
- */
-template<class F, size_t Size>
-class RingBuf : public Print {
- public:
-  /**
-   * RingBuf Constructor.
-   */
-  RingBuf() {}
-  /**
-   * Initialize RingBuf.
-   * \param[in] file Underlying file.
-   */
-  void begin(F* file) {
-    m_file = file;
-    m_count = 0;
-    m_head = 0;
-    m_tail = 0;
-    clearWriteError();
-  }
-  /**
-   *
-   * \return the RingBuf free space in bytes. Not ISR callable.
-   */
-  size_t bytesFree() const {
-    size_t count;
-    noInterrupts();
-    count = m_count;
-    interrupts();
-    return Size - count;
-  }
-  /**
-   * \return the RingBuf free space in bytes. ISR callable.
-   */
-  size_t bytesFreeIsr() const {
-    return Size - m_count;
-  }
-  /**
-   * \return the RingBuf used space in bytes. Not ISR callable.
-   */
-  size_t bytesUsed() const {
-    size_t count;
-    noInterrupts();
-    count = m_count;
-    interrupts();
-    return count;
-  }
-  /**
-   * \return the RingBuf used space in bytes.  ISR callable.
-   */
-  size_t bytesUsedIsr() const {
-    return m_count;
-  }
-  /**
-   * Copy data to the RingBuf from buf.
-   * The number of bytes copied may be less than count if
-   * count is greater than bytesFree.
-   *
-   * This function may be used in an ISR with writeOut()
-   * in non-interrupt code.
-   *
-   * \param[in] buf Location of data to be copied.
-   * \param[in] count number of bytes to be copied.
-   * \return Number of bytes actually copied.
-   */
-  size_t memcpyIn(const void* buf, size_t count) {
-    const uint8_t* src = (const uint8_t*)buf;
-    size_t n = Size - m_count;
-    if (count > n) {
-      count = n;
-    }
-    size_t nread = 0;
-    while (nread != count) {
-        n = minSize(Size - m_head, count - nread);
-        memcpyBuf(m_buf + m_head, src + nread, n);
-        m_head = advance(m_head, n);
-        nread += n;
-    }
-    m_count += nread;
-    return nread;
-  }
-  /**
-   * Copy date from the RingBuf to buf.
-   * The number of bytes copied may be less than count if
-   * bytesUsed is less than count.
-   *
-   * This function may be used in an ISR with readIn() in
-   * non-interrupt code.
-   *
-   * \param[out] buf Location to receive the data.
-   * \param[in] count number of bytes to be copied.
-   * \return Number of bytes actually copied.
-   */
-  size_t memcpyOut(void* buf, size_t count) {
-    uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
-    size_t nwrite = 0;
-    size_t n = m_count;
-    if (count > n) {
-      count = n;
-    }
-    while (nwrite != count) {
-      n = minSize(Size - m_tail, count - nwrite);
-      memcpyBuf(dst + nwrite, m_buf + m_tail, n);
-      m_tail = advance(m_tail, n);
-      nwrite += n;
-    }
-    m_count -= nwrite;
-    return nwrite;
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written.
-   */
-  size_t printField(double value, char term, uint8_t prec = 2) {
-    char buf[24];
-    char* str = buf + sizeof(buf);
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    str = fmtDouble(str, value, prec, false);
-    return write(str, buf + sizeof(buf) - str);
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  size_t printField(float value, char term, uint8_t prec = 2) {
-    return printField(static_cast<double>(value), term, prec);
-  }
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.  Use '\\n' for CR LF.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  template <typename Type>
-  size_t printField(Type value, char term) {
-    char sign = 0;
-    char buf[3*sizeof(Type) + 3];
-    char* str = buf + sizeof(buf);
-
-    if (term) {
-      *--str = term;
-      if (term == '\n') {
-        *--str = '\r';
-      }
-    }
-    if (value < 0) {
-      value = -value;
-      sign = '-';
-    }
-    if (sizeof(Type) < 4) {
-      str = fmtBase10(str, (uint16_t)value);
-    } else {
-      str = fmtBase10(str, (uint32_t)value);
-    }
-    if (sign) {
-      *--str = sign;
-    }
-    return write((const uint8_t*)str, &buf[sizeof(buf)] - str);
-  }
-  /**
-   * Read data into the RingBuf from the underlying file.
-   * the number of bytes read may be less than count if
-   * bytesFree is less than count.
-   *
-   * This function may be used in non-interrupt code with
-   * memcopyOut() in an ISR.
-   *
-   * \param[in] count number of bytes to be read.
-   * \return Number of bytes actually read.
-   */
-  size_t readIn(size_t count) {
-    size_t nread = 0;
-    size_t n = bytesFree();  // Protected from interrupts.
-    if (count > n) {
-      count = n;
-    }
-    while (nread != count) {
-        n = minSize(Size - m_head, count - nread);
-        if ((size_t)m_file->read(m_buf + m_head, n) != n) {
-          return nread;
-        }
-        m_head = advance(m_head, n);
-        nread += n;
-    }
-    noInterrupts();
-    m_count += nread;
-    interrupts();
-    return nread;
-  }
-  /**
-   * Write all data in the RingBuf to the underlying file.
-   * \return true for success.
-   */
-  bool sync() {
-    size_t n = bytesUsed();
-    return writeOut(n) == n;
-  }
-  /**
-   * Copy data to the RingBuf from buf.
-   *
-   * The number of bytes copied may be less than count if
-   * count is greater than bytesFree.
-   * Use getWriteError() to check for print errors and
-   * clearWriteError() to clear error.
-   *
-   * \param[in] buf Location of data to be written.
-   * \param[in] count number of bytes to be written.
-   * \return Number of bytes actually written.
-   */
-  size_t write(const void* buf, size_t count) {
-    if (count > bytesFree()) {
-      setWriteError();
-    }
-    return memcpyIn(buf, count);
-  }
-  /**
-   * Copy str to RingBuf.
-   *
-   * \param[in] str Location of data to be written.
-   * \return Number of bytes actually written.
-   */
-  size_t write(const char* str) {
-    return Print::write(str);
-  }
-  /**
-   * Override virtual function in Print for efficiency.
-   *
-   * \param[in] buf Location of data to be written.
-   * \param[in] count number of bytes to be written.
-   * \return Number of bytes actually written.
-   */
-  size_t write(const uint8_t* buf, size_t count) override {
-    return write((const void*)buf, count);
-  }
-  /**
-   * Required function for Print.
-   * \param[in] data Byte to be written.
-   * \return Number of bytes actually written.
-   */
-  size_t write(uint8_t data) override {
-    return write(&data, 1);
-  }
-  /**
-   * Write data to file from RingBuf buffer.
-   * \param[in] count number of bytes to be written.
-   *
-   * The number of bytes written may be less than count if
-   * bytesUsed is less than count or if an error occurs.
-   *
-   * This function may be used in non-interrupt code with
-   * memcopyIn() in an ISR.
-   *
-   * \return Number of bytes actually written.
-   */
-  size_t writeOut(size_t count) {
-    size_t n = bytesUsed();  // Protected from interrupts;
-     if (count > n) {
-      count = n;
-    }
-    size_t nwrite = 0;
-    while (nwrite != count) {
-      n = minSize(Size - m_tail, count - nwrite);
-      if (m_file->write(m_buf + m_tail, n) != n) {
-        break;
-      }
-      m_tail = advance(m_tail, n);
-      nwrite += n;
-    }
-    noInterrupts();
-    m_count -= nwrite;
-    interrupts();
-    return nwrite;
-  }
-
- private:
-  uint8_t __attribute__((aligned(4))) m_buf[Size];
-  F* m_file = nullptr;
-  volatile size_t m_count;
-  size_t m_head;
-  size_t m_tail;
-
-  size_t advance(size_t index, size_t n) {
-    index += n;
-    return index < Size ? index : index - Size;
-  }
-  // avoid macro MIN
-  size_t minSize(size_t a, size_t b) {return a < b ? a : b;}
-};
-#endif  // RingBuf_h

lib/SdFat_NoArduino/src/SdCard/SdCard.h

@@ -1,82 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef SdCard_h
-#define SdCard_h
-#include "SdioCard.h"
-#include "SdSpiCard.h"
-#if HAS_SDIO_CLASS
-typedef SdCardInterface SdCard;
-#else  // HAS_SDIO_CLASS
-typedef SdSpiCard SdCard;
-#endif  // HAS_SDIO_CLASS
-/** Determine card configuration type.
- *
- * \param[in] cfg Card configuration.
- * \return true if SPI.
- */
-inline bool isSpi(SdSpiConfig cfg) {(void)cfg; return true;}
-/** Determine card configuration type.
- *
- * \param[in] cfg Card configuration.
- * \return true if SPI.
- */
-inline bool isSpi(SdioConfig cfg) {(void)cfg; return false;}
-/**
- * \class SdCardFactory
- * \brief Setup a SPI card or SDIO card.
- */
-class SdCardFactory {
- public:
-  /** Initialize SPI card.
-   *
-   * \param[in] config SPI configuration.
-   * \return generic card pointer.
-   */
-  SdCard* newCard(SdSpiConfig config) {
-    m_spiCard.begin(config);
-    return &m_spiCard;
-  }
-  /** Initialize SDIO card.
-   *
-   * \param[in] config SDIO configuration.
-   * \return generic card pointer or nullptr if SDIO is not supported.
-   */
-  SdCard* newCard(SdioConfig config) {
-#if HAS_SDIO_CLASS
-    m_sdioCard.begin(config);
-    return &m_sdioCard;
-#else  // HAS_SDIO_CLASS
-    (void)config;
-    return nullptr;
-#endif  // HAS_SDIO_CLASS
-  }
-
- private:
-#if HAS_SDIO_CLASS
-  SdioCard m_sdioCard;
-#endif  // HAS_SDIO_CLASS
-  SdSpiCard m_spiCard;
-};
-#endif  // SdCard_h

lib/SdFat_NoArduino/src/SdCard/SdCardInfo.cpp

@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "SdCardInfo.h"
-//------------------------------------------------------------------------------
-#undef SD_CARD_ERROR
-#define SD_CARD_ERROR(e, m) case SD_CARD_ERROR_##e: pr->print(F(#e)); break;
-void printSdErrorSymbol(print_t* pr, uint8_t code) {
-  pr->print(F("SD_CARD_ERROR_"));
-  switch (code) {
-    SD_ERROR_CODE_LIST
-    default: pr->print(F("UNKNOWN"));
-  }
-}
-//------------------------------------------------------------------------------
-#undef SD_CARD_ERROR
-#define SD_CARD_ERROR(e, m) case SD_CARD_ERROR_##e: pr->print(F(m)); break;
-void printSdErrorText(print_t* pr, uint8_t code) {
-  switch
-  (code) {
-    SD_ERROR_CODE_LIST
-    default: pr->print(F("Unknown error"));
-  }
-}

lib/SdFat_NoArduino/src/SdCard/SdCardInfo.h

@@ -1,420 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef SdCardInfo_h
-#define SdCardInfo_h
-#include <stdint.h>
-#include "../common/SysCall.h"
-// Based on the document:
-//
-// SD Specifications
-// Part 1
-// Physical Layer
-// Simplified Specification
-// Version 8.00
-// Sep 23, 2020
-//
-// https://www.sdcard.org/downloads/pls/
-#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
-// SD registers are big endian.
-#error bit fields in structures assume little endian processor.
-#endif  // __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
-//------------------------------------------------------------------------------
-// SD card errors
-// See the SD Specification for command info.
-#define SD_ERROR_CODE_LIST\
-  SD_CARD_ERROR(NONE, "No error")\
-  SD_CARD_ERROR(CMD0, "Card reset failed")\
-  SD_CARD_ERROR(CMD2, "SDIO read CID")\
-  SD_CARD_ERROR(CMD3, "SDIO publish RCA")\
-  SD_CARD_ERROR(CMD6, "Switch card function")\
-  SD_CARD_ERROR(CMD7, "SDIO card select")\
-  SD_CARD_ERROR(CMD8, "Send and check interface settings")\
-  SD_CARD_ERROR(CMD9, "Read CSD data")\
-  SD_CARD_ERROR(CMD10, "Read CID data")\
-  SD_CARD_ERROR(CMD12, "Stop multiple block read")\
-  SD_CARD_ERROR(CMD13, "Read card status")\
-  SD_CARD_ERROR(CMD17, "Read single block")\
-  SD_CARD_ERROR(CMD18, "Read multiple blocks")\
-  SD_CARD_ERROR(CMD24, "Write single block")\
-  SD_CARD_ERROR(CMD25, "Write multiple blocks")\
-  SD_CARD_ERROR(CMD32, "Set first erase block")\
-  SD_CARD_ERROR(CMD33, "Set last erase block")\
-  SD_CARD_ERROR(CMD38, "Erase selected blocks")\
-  SD_CARD_ERROR(CMD58, "Read OCR register")\
-  SD_CARD_ERROR(CMD59, "Set CRC mode")\
-  SD_CARD_ERROR(ACMD6, "Set SDIO bus width")\
-  SD_CARD_ERROR(ACMD13, "Read extended status")\
-  SD_CARD_ERROR(ACMD23, "Set pre-erased count")\
-  SD_CARD_ERROR(ACMD41, "Activate card initialization")\
-  SD_CARD_ERROR(ACMD51, "Read SCR data")\
-  SD_CARD_ERROR(READ_TOKEN, "Bad read data token")\
-  SD_CARD_ERROR(READ_CRC, "Read CRC error")\
-  SD_CARD_ERROR(READ_FIFO, "SDIO fifo read timeout")\
-  SD_CARD_ERROR(READ_REG, "Read CID or CSD failed.")\
-  SD_CARD_ERROR(READ_START, "Bad readStart argument")\
-  SD_CARD_ERROR(READ_TIMEOUT, "Read data timeout")\
-  SD_CARD_ERROR(STOP_TRAN, "Multiple block stop failed")\
-  SD_CARD_ERROR(TRANSFER_COMPLETE, "SDIO transfer complete")\
-  SD_CARD_ERROR(WRITE_DATA, "Write data not accepted")\
-  SD_CARD_ERROR(WRITE_FIFO, "SDIO fifo write timeout")\
-  SD_CARD_ERROR(WRITE_START, "Bad writeStart argument")\
-  SD_CARD_ERROR(WRITE_PROGRAMMING, "Flash programming")\
-  SD_CARD_ERROR(WRITE_TIMEOUT, "Write timeout")\
-  SD_CARD_ERROR(DMA, "DMA transfer failed")\
-  SD_CARD_ERROR(ERASE, "Card did not accept erase commands")\
-  SD_CARD_ERROR(ERASE_SINGLE_SECTOR, "Card does not support erase")\
-  SD_CARD_ERROR(ERASE_TIMEOUT, "Erase command timeout")\
-  SD_CARD_ERROR(INIT_NOT_CALLED, "Card has not been initialized")\
-  SD_CARD_ERROR(INVALID_CARD_CONFIG, "Invalid card config")\
-  SD_CARD_ERROR(FUNCTION_NOT_SUPPORTED, "Unsupported SDIO command")
-
-enum {
-#define SD_CARD_ERROR(e, m) SD_CARD_ERROR_##e,
-  SD_ERROR_CODE_LIST
-#undef SD_CARD_ERROR
-  SD_CARD_ERROR_UNKNOWN
-};
-void printSdErrorSymbol(print_t* pr, uint8_t code);
-void printSdErrorText(print_t* pr, uint8_t code);
-//------------------------------------------------------------------------------
-// card types
-/** Standard capacity V1 SD card */
-const uint8_t SD_CARD_TYPE_SD1  = 1;
-/** Standard capacity V2 SD card */
-const uint8_t SD_CARD_TYPE_SD2  = 2;
-/** High Capacity SD card */
-const uint8_t SD_CARD_TYPE_SDHC = 3;
-//------------------------------------------------------------------------------
-// SD operation timeouts
-/** CMD0 retry count */
-const uint8_t SD_CMD0_RETRY = 10;
-/** command timeout ms */
-const uint16_t SD_CMD_TIMEOUT = 300;
-/** erase timeout ms */
-const uint16_t SD_ERASE_TIMEOUT = 10000;
-/** init timeout ms */
-const uint16_t SD_INIT_TIMEOUT = 2000;
-/** read timeout ms */
-const uint16_t SD_READ_TIMEOUT = 300;
-/** write time out ms */
-const uint16_t SD_WRITE_TIMEOUT = 600;
-//------------------------------------------------------------------------------
-// SD card commands
-/** GO_IDLE_STATE - init card in spi mode if CS low */
-const uint8_t CMD0 = 0X00;
-/** ALL_SEND_CID - Asks any card to send the CID. */
-const uint8_t CMD2 = 0X02;
-/** SEND_RELATIVE_ADDR - Ask the card to publish a new RCA. */
-const uint8_t CMD3 = 0X03;
-/** SWITCH_FUNC - Switch Function Command */
-const uint8_t CMD6 = 0X06;
-/** SELECT/DESELECT_CARD - toggles between the stand-by and transfer states. */
-const uint8_t CMD7 = 0X07;
-/** SEND_IF_COND - verify SD Memory Card interface operating condition.*/
-const uint8_t CMD8 = 0X08;
-/** SEND_CSD - read the Card Specific Data (CSD register) */
-const uint8_t CMD9 = 0X09;
-/** SEND_CID - read the card identification information (CID register) */
-const uint8_t CMD10 = 0X0A;
-/** VOLTAGE_SWITCH -Switch to 1.8V bus signaling level. */
-const uint8_t CMD11 = 0X0B;
-/** STOP_TRANSMISSION - end multiple sector read sequence */
-const uint8_t CMD12 = 0X0C;
-/** SEND_STATUS - read the card status register */
-const uint8_t CMD13 = 0X0D;
-/** READ_SINGLE_SECTOR - read a single data sector from the card */
-const uint8_t CMD17 = 0X11;
-/** READ_MULTIPLE_SECTOR - read multiple data sectors from the card */
-const uint8_t CMD18 = 0X12;
-/** WRITE_SECTOR - write a single data sector to the card */
-const uint8_t CMD24 = 0X18;
-/** WRITE_MULTIPLE_SECTOR - write sectors of data until a STOP_TRANSMISSION */
-const uint8_t CMD25 = 0X19;
-/** ERASE_WR_BLK_START - sets the address of the first sector to be erased */
-const uint8_t CMD32 = 0X20;
-/** ERASE_WR_BLK_END - sets the address of the last sector of the continuous
-    range to be erased*/
-const uint8_t CMD33 = 0X21;
-/** ERASE - erase all previously selected sectors */
-const uint8_t CMD38 = 0X26;
-/** APP_CMD - escape for application specific command */
-const uint8_t CMD55 = 0X37;
-/** READ_OCR - read the OCR register of a card */
-const uint8_t CMD58 = 0X3A;
-/** CRC_ON_OFF - enable or disable CRC checking */
-const uint8_t CMD59 = 0X3B;
-/** SET_BUS_WIDTH - Defines the data bus width for data transfer. */
-const uint8_t ACMD6 = 0X06;
-/** SD_STATUS - Send the SD Status. */
-const uint8_t ACMD13 = 0X0D;
-/** SET_WR_BLK_ERASE_COUNT - Set the number of write sectors to be
-     pre-erased before writing */
-const uint8_t ACMD23 = 0X17;
-/** SD_SEND_OP_COMD - Sends host capacity support information and
-    activates the card's initialization process */
-const uint8_t ACMD41 = 0X29;
-/** Reads the SD Configuration Register (SCR). */
-const uint8_t ACMD51 = 0X33;
-//==============================================================================
-// CARD_STATUS
-/** The command's argument was out of the allowed range for this card. */
-const uint32_t CARD_STATUS_OUT_OF_RANGE = 1UL << 31;
-/** A misaligned address which did not match the sector length. */
-const uint32_t CARD_STATUS_ADDRESS_ERROR = 1UL << 30;
-/** The transferred sector length is not allowed for this card. */
-const uint32_t CARD_STATUS_SECTOR_LEN_ERROR = 1UL << 29;
-/** An error in the sequence of erase commands occurred. */
-const uint32_t CARD_STATUS_ERASE_SEQ_ERROR = 1UL <<28;
-/** An invalid selection of write-sectors for erase occurred. */
-const uint32_t CARD_STATUS_ERASE_PARAM = 1UL << 27;
-/** Set when the host attempts to write to a protected sector. */
-const uint32_t CARD_STATUS_WP_VIOLATION = 1UL << 26;
-/** When set, signals that the card is locked by the host. */
-const uint32_t CARD_STATUS_CARD_IS_LOCKED = 1UL << 25;
-/** Set when a sequence or password error has been detected. */
-const uint32_t CARD_STATUS_LOCK_UNLOCK_FAILED = 1UL << 24;
-/** The CRC check of the previous command failed. */
-const uint32_t CARD_STATUS_COM_CRC_ERROR = 1UL << 23;
-/** Command not legal for the card state. */
-const uint32_t CARD_STATUS_ILLEGAL_COMMAND = 1UL << 22;
-/** Card internal ECC was applied but failed to correct the data. */
-const uint32_t CARD_STATUS_CARD_ECC_FAILED = 1UL << 21;
-/** Internal card controller error */
-const uint32_t CARD_STATUS_CC_ERROR = 1UL << 20;
-/** A general or an unknown error occurred during the operation. */
-const uint32_t CARD_STATUS_ERROR = 1UL << 19;
-// bits 19, 18, and 17 reserved.
-/** Permanent WP set or attempt to change read only values of  CSD. */
-const uint32_t CARD_STATUS_CSD_OVERWRITE = 1UL <<16;
-/** partial address space was erased due to write protect. */
-const uint32_t CARD_STATUS_WP_ERASE_SKIP = 1UL << 15;
-/** The command has been executed without using the internal ECC. */
-const uint32_t CARD_STATUS_CARD_ECC_DISABLED = 1UL << 14;
-/** out of erase sequence command was received. */
-const uint32_t CARD_STATUS_ERASE_RESET = 1UL << 13;
-/** The state of the card when receiving the command.
- * 0 = idle
- * 1 = ready
- * 2 = ident
- * 3 = stby
- * 4 = tran
- * 5 = data
- * 6 = rcv
- * 7 = prg
- * 8 = dis
- * 9-14 = reserved
- * 15 = reserved for I/O mode
- */
-const uint32_t CARD_STATUS_CURRENT_STATE = 0XF << 9;
-/** Shift for current state. */
-const uint32_t CARD_STATUS_CURRENT_STATE_SHIFT = 9;
-/** Corresponds to buffer empty signaling on the bus. */
-const uint32_t CARD_STATUS_READY_FOR_DATA = 1UL << 8;
-// bit 7 reserved.
-/** Extension Functions may set this bit to get host to deal with events. */
-const uint32_t CARD_STATUS_FX_EVENT = 1UL << 6;
-/** The card will expect ACMD, or the command has been interpreted as ACMD */
-const uint32_t CARD_STATUS_APP_CMD = 1UL << 5;
-// bit 4 reserved.
-/** Error in the sequence of the authentication process. */
-const uint32_t CARD_STATUS_AKE_SEQ_ERROR = 1UL << 3;
-// bits 2,1, and 0 reserved for manufacturer test mode.
-//==============================================================================
-/** status for card in the ready state */
-const uint8_t R1_READY_STATE = 0X00;
-/** status for card in the idle state */
-const uint8_t R1_IDLE_STATE = 0X01;
-/** status bit for illegal command */
-const uint8_t R1_ILLEGAL_COMMAND = 0X04;
-/** start data token for read or write single sector*/
-const uint8_t DATA_START_SECTOR = 0XFE;
-/** stop token for write multiple sectors*/
-const uint8_t STOP_TRAN_TOKEN = 0XFD;
-/** start data token for write multiple sectors*/
-const uint8_t WRITE_MULTIPLE_TOKEN = 0XFC;
-/** mask for data response tokens after a write sector operation */
-const uint8_t DATA_RES_MASK = 0X1F;
-/** write data accepted token */
-const uint8_t DATA_RES_ACCEPTED = 0X05;
-//==============================================================================
-/**
- * \class CID
- * \brief Card IDentification (CID) register.
- */
-typedef struct CID {
-  // byte 0
-  /** Manufacturer ID */
-  uint8_t mid;
-  // byte 1-2
-  /** OEM/Application ID. */
-  char oid[2];
-  // byte 3-7
-  /** Product name. */
-  char pnm[5];
-  // byte 8
-  /** Product revision - n.m two 4-bit nibbles. */
-  uint8_t prv;
-  // byte 9-12
-  /** Product serial 32-bit number Big Endian format. */
-  uint8_t psn8[4];
-  // byte 13-14
-  /** Manufacturing date big endian - four nibbles RYYM Reserved Year Month. */
-  uint8_t mdt[2];
-  // byte 15
-  /** CRC7 bits 1-7 checksum, bit 0 always 1 */
-  uint8_t crc;
-  // Extract big endian fields.
-  /** \return major revision number. */
-  int prvN() const {return prv >> 4;}
-  /** \return minor revision number. */
-  int prvM() const {return prv & 0XF;}
-  /** \return Manufacturing Year. */
-  int mdtYear() const {return 2000 + ((mdt[0] & 0XF) << 4) + (mdt[1] >> 4);}
-  /** \return Manufacturing Month. */
-  int mdtMonth() const {return mdt[1] & 0XF;}
-  /** \return Product Serial Number. */
-  uint32_t psn() const {
-  return (uint32_t)psn8[0] << 24 |
-         (uint32_t)psn8[1] << 16 |
-         (uint32_t)psn8[2] <<  8 |
-         (uint32_t)psn8[3];
-  }
-} __attribute__((packed)) cid_t;
-//==============================================================================
-/**
- * \class CSD
- * \brief Union of old and new style CSD register.
- */
-typedef struct CSD {
-  /** union of all CSD versions */
-  uint8_t csd[16];
-  // Extract big endian fields.
-  /** \return Capacity in sectors */
-  uint32_t capacity() const {
-    uint32_t c_size;
-    uint8_t ver = csd[0] >> 6;
-    if (ver == 0) {
-      c_size = (uint32_t)(csd[6] & 3) << 10;
-      c_size |= (uint32_t)csd[7] << 2 | csd[8] >> 6;
-      uint8_t c_size_mult = (csd[9] & 3) << 1 | csd[10] >> 7;
-      uint8_t read_bl_len = csd[5] & 15;
-      return (c_size + 1) << (c_size_mult + read_bl_len + 2 - 9);
-    } else if (ver == 1) {
-      c_size = (uint32_t)(csd[7] & 63) << 16;
-      c_size |= (uint32_t)csd[8] << 8;
-      c_size |= csd[9];
-      return (c_size + 1) << 10;
-    } else {
-      return 0;
-    }
-  }
-  /** \return true if erase granularity is single block. */
-  bool eraseSingleBlock() const {return csd[10] & 0X40;}
-  /** \return erase size in 512 byte blocks if eraseSingleBlock is false. */
-  int eraseSize() const {return ((csd[10] & 0X3F) << 1 | csd[11] >> 7) + 1;}
-  /** \return true if the contents is copied or true if original. */
-  bool copy() const {return csd[14] & 0X40;}
-  /** \return true if the entire card is permanently write protected. */
-  bool permWriteProtect() const {return  csd[14] & 0X20;}
-  /** \return true if the entire card is temporarily write protected. */
-  bool tempWriteProtect() const {return  csd[14] & 0X10;}
-} csd_t;
-//==============================================================================
-/**
- * \class SCR
- * \brief SCR register.
- */
-typedef struct SCR {
-  /** Bytes 0-3 SD Association, bytes 4-7 reserved for manufacturer. */
-  uint8_t scr[8];
-  /** \return SCR_STRUCTURE field  - must be zero.*/
-  uint8_t srcStructure() {return scr[0] >> 4;}
-  /** \return SD_SPEC field 0 - v1.0 or V1.01, 1 - 1.10, 2 - V2.00 or greater */
-  uint8_t sdSpec() {return scr[0] & 0XF;}
-  /** \return false if all zero, true if all one. */
-  bool dataAfterErase() {return 0X80 & scr[1];}
-  /** \return CPRM Security Version. */
-  uint8_t sdSecurity() {return (scr[1] >> 4) & 0X7;}
-  /** \return 0101b.  */
-  uint8_t sdBusWidths() {return scr[1] & 0XF;}
-  /** \return true if V3.0 or greater. */
-  bool sdSpec3() {return scr[2] & 0X80;}
-  /** \return if true and sdSpecX is zero V4.xx. */
-  bool sdSpec4() {return scr[2] & 0X4;}
-  /** \return nonzero for version 5 or greater if sdSpec == 2,
-              sdSpec3 == true. Version is return plus four.*/
-  uint8_t sdSpecX() {return (scr[2] & 0X3) << 2 | scr[3] >> 6;}
-  /** \return bit map for support CMD58/59, CMD48/49, CMD23, and CMD20 */
-  uint8_t cmdSupport() {return scr[3] &0XF;}
-  /** \return SD spec version */
-  int16_t sdSpecVer() {
-    if (sdSpec() > 2) {
-      return -1;
-    } else if (sdSpec() < 2) {
-      return sdSpec() ? 110 : 101;
-    } else if (!sdSpec3()) {
-      return 200;
-    } else if (!sdSpec4() && !sdSpecX()) {
-      return 300;
-    }
-    return 400 + 100*sdSpecX();
-  }
-} scr_t;
-//==============================================================================
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-// fields are big endian
-typedef struct SdStatus {
-  //
-  uint8_t busWidthSecureMode;
-  uint8_t reserved1;
-  // byte 2
-  uint8_t sdCardType[2];
-  // byte 4
-  uint8_t sizeOfProtectedArea[4];
-  // byte 8
-  uint8_t speedClass;
-  // byte 9
-  uint8_t performanceMove;
-  // byte 10
-  uint8_t auSize;
-  // byte 11
-  uint8_t eraseSize[2];
-  // byte 13
-  uint8_t eraseTimeoutOffset;
-  // byte 14
-  uint8_t uhsSpeedAuSize;
-  // byte 15
-  uint8_t videoSpeed;
-  // byte 16
-  uint8_t vscAuSize[2];
-  // byte 18
-  uint8_t susAddr[3];
-  // byte 21
-  uint8_t reserved2[3];
-  // byte 24
-  uint8_t reservedManufacturer[40];
-} SdStatus_t;
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-#endif  // SdCardInfo_h

lib/SdFat_NoArduino/src/SdCard/SdCardInterface.h

@@ -1,129 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef SdCardInterface_h
-#define SdCardInterface_h
-#include "../common/FsBlockDeviceInterface.h"
-#include "SdCardInfo.h"
-/**
- * \class SdCardInterface
- * \brief Abstract interface for an SD card.
- */
-class SdCardInterface : public FsBlockDeviceInterface {
- public:
-  /** CMD6 Switch mode: Check Function Set Function.
-   * \param[in] arg CMD6 argument.
-   * \param[out] status return status data.
-   *
-   * \return true for success or false for failure.
-   */
-  virtual bool cardCMD6(uint32_t arg, uint8_t* status) = 0;
-  /** end use of card */
-  virtual void end() = 0;
-   /** Erase a range of sectors.
-   *
-   * \param[in] firstSector The address of the first sector in the range.
-   * \param[in] lastSector The address of the last sector in the range.
-   *
-   * \return true for success or false for failure.
-   */
-  virtual bool erase(uint32_t firstSector, uint32_t lastSector) = 0;
-  /** \return error code. */
-  virtual uint8_t errorCode() const = 0;
-  /** \return error data. */
-  virtual uint32_t errorData() const = 0;
-  /** \return true if card is busy. */
-  virtual bool isBusy() = 0;
-  /** \return false by default */
-  virtual bool hasDedicatedSpi() {return false;}
-  /** \return false by default */
-  bool virtual isDedicatedSpi() {return false;}
-  /** Set SPI sharing state
-   * \param[in] value desired state.
-   * \return false by default.
-   */
-  virtual bool setDedicatedSpi(bool value) {
-    (void)value;
-    return false;
-  }
-  /**
-   * Read a card's CID register.
-   *
-   * \param[out] cid pointer to area for returned data.
-   *
-   * \return true for success or false for failure.
-   */
-  virtual bool readCID(cid_t* cid) = 0;
-   /**
-   * Read a card's CSD register.
-   *
-   * \param[out] csd pointer to area for returned data.
-   *
-   * \return true for success or false for failure.
-   */
-  virtual bool readCSD(csd_t* csd) = 0;
-  /** Read OCR register.
-   *
-   * \param[out] ocr Value of OCR register.
-   * \return true for success or false for failure.
-   */
-  virtual bool readOCR(uint32_t* ocr) = 0;
-  /** Read SCR register.
-   *
-   * \param[out] scr Value of SCR register.
-   * \return true for success or false for failure.
-   */
-  virtual bool readSCR(scr_t *scr) = 0;
-  /**
-   * Determine the size of an SD flash memory card.
-   *
-   * \return The number of 512 byte data sectors in the card
-   *         or zero if an error occurs.
-   */
-  virtual uint32_t sectorCount() = 0;
-  /** \return card status. */
-  virtual uint32_t status() {return 0XFFFFFFFF;}
-  /** Return the card type: SD V1, SD V2 or SDHC/SDXC
-   * \return 0 - SD V1, 1 - SD V2, or 3 - SDHC/SDXC.
-   */
-  virtual uint8_t type() const = 0;
-  /** Write one data sector in a multiple sector write sequence.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-
-  virtual bool writeData(const uint8_t* src) = 0;
-  /** Start a write multiple sectors sequence.
-   *
-   * \param[in] sector Address of first sector in sequence.
-   *
-   * \return true for success or false for failure.
-   */
-  virtual bool writeStart(uint32_t sector) = 0;
-  /** End a write multiple sectors sequence.
-   * \return true for success or false for failure.
-   */
-  virtual bool writeStop() = 0;
-};
-#endif  // SdCardInterface_h

lib/SdFat_NoArduino/src/SdCard/SdSpiCard.cpp

@@ -1,777 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "SdSpiCard.h"
-//==============================================================================
-class Timeout {
- public:
-  Timeout() {}
-  explicit Timeout(uint16_t ms) {set(ms);}
-  uint16_t millis16() {return millis();}
-  void set(uint16_t ms) {
-    m_endTime = ms + millis16();
-  }
-  bool timedOut() {
-    return (int16_t)(m_endTime - millis16()) < 0;
-  }
- private:
-  uint16_t m_endTime;
-};
-//==============================================================================
-#if USE_SD_CRC
-// CRC functions
-//------------------------------------------------------------------------------
-static uint8_t CRC7(const uint8_t* data, uint8_t n) {
-  uint8_t crc = 0;
-  for (uint8_t i = 0; i < n; i++) {
-    uint8_t d = data[i];
-    for (uint8_t j = 0; j < 8; j++) {
-      crc <<= 1;
-      if ((d & 0x80) ^ (crc & 0x80)) {
-        crc ^= 0x09;
-      }
-      d <<= 1;
-    }
-  }
-  return (crc << 1) | 1;
-}
-//------------------------------------------------------------------------------
-#if USE_SD_CRC == 1
-// Shift based CRC-CCITT
-// uses the x^16,x^12,x^5,x^1 polynomial.
-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 = (uint8_t)(crc >> 8) | (crc << 8);
-    crc ^= data[i];
-    crc ^= (uint8_t)(crc & 0xff) >> 4;
-    crc ^= crc << 12;
-    crc ^= (crc & 0xff) << 5;
-  }
-  return crc;
-}
-#elif USE_SD_CRC > 1  // CRC_CCITT
-//------------------------------------------------------------------------------
-// Table based CRC-CCITT
-// uses the x^16,x^12,x^5,x^1 polynomial.
-#ifdef __AVR__
-static const uint16_t crctab[] PROGMEM = {
-#else  // __AVR__
-static const uint16_t crctab[] = {
-#endif  // __AVR__
-  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
-  0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
-  0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
-  0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
-  0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
-  0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
-  0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
-  0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
-  0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
-  0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
-  0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
-  0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
-  0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
-  0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
-  0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
-  0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
-  0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
-  0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
-  0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
-  0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
-  0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
-  0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-  0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
-  0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
-  0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
-  0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
-  0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
-  0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
-  0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
-  0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
-  0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
-  0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
-};
-static uint16_t CRC_CCITT(const uint8_t* data, size_t n) {
-  uint16_t crc = 0;
-  for (size_t i = 0; i < n; i++) {
-#ifdef __AVR__
-    crc = pgm_read_word(&crctab[(crc >> 8 ^ data[i]) & 0XFF]) ^ (crc << 8);
-#else  // __AVR__
-    crc = crctab[(crc >> 8 ^ data[i]) & 0XFF] ^ (crc << 8);
-#endif  // __AVR__
-  }
-  return crc;
-}
-#endif  // CRC_CCITT
-#endif  // USE_SD_CRC
-//==============================================================================
-// SharedSpiCard member functions
-//------------------------------------------------------------------------------
-bool SharedSpiCard::begin(SdSpiConfig spiConfig) {
-  Timeout timeout;
-  m_spiActive = false;
-  m_beginCalled = false;
-  m_errorCode = SD_CARD_ERROR_NONE;
-  m_type = 0;
-  m_csPin = spiConfig.csPin;
-#if SPI_DRIVER_SELECT >= 2
-  m_spiDriverPtr = spiConfig.spiPort;
-  if (!m_spiDriverPtr) {
-    error(SD_CARD_ERROR_INVALID_CARD_CONFIG);
-    goto fail;
-  }
-#endif  // SPI_DRIVER_SELECT
-  sdCsInit(m_csPin);
-  spiUnselect();
-  spiSetSckSpeed(1000UL*SD_MAX_INIT_RATE_KHZ);
-  spiBegin(spiConfig);
-  m_beginCalled = true;
-  uint32_t arg;
-  m_state = IDLE_STATE;
-  spiStart();
-
-  // must supply min of 74 clock cycles with CS high.
-  spiUnselect();
-  for (uint8_t i = 0; i < 10; i++) {
-    spiSend(0XFF);
-  }
-  spiSelect();
-  // command to go idle in SPI mode
-  for (uint8_t i = 1;; i++) {
-    if (cardCommand(CMD0, 0) == R1_IDLE_STATE) {
-      break;
-    }
-    if (i == SD_CMD0_RETRY) {
-      error(SD_CARD_ERROR_CMD0);
-      goto fail;
-    }
-    // Force any active transfer to end for an already initialized card.
-    for (uint8_t j = 0; j < 0XFF; j++) {
-      spiSend(0XFF);
-    }
-  }
-#if USE_SD_CRC
-  if (cardCommand(CMD59, 1) != R1_IDLE_STATE) {
-    error(SD_CARD_ERROR_CMD59);
-    goto fail;
-  }
-#endif  // USE_SD_CRC
-  // check SD version
-  if (!(cardCommand(CMD8, 0x1AA) & R1_ILLEGAL_COMMAND)) {
-    type(SD_CARD_TYPE_SD2);
-    for (uint8_t i = 0; i < 4; i++) {
-      m_status = spiReceive();
-    }
-    if (m_status != 0XAA) {
-      error(SD_CARD_ERROR_CMD8);
-      goto fail;
-    }
-  } else {
-    type(SD_CARD_TYPE_SD1);
-  }
-  // initialize card and send host supports SDHC if SD2
-  arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
-  timeout.set(SD_INIT_TIMEOUT);
-  while (cardAcmd(ACMD41, arg) != R1_READY_STATE) {
-    // check for timeout
-    if (timeout.timedOut()) {
-      error(SD_CARD_ERROR_ACMD41);
-      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;
-    }
-    if ((spiReceive() & 0XC0) == 0XC0) {
-      type(SD_CARD_TYPE_SDHC);
-    }
-    // Discard rest of ocr - contains allowed voltage range.
-    for (uint8_t i = 0; i < 3; i++) {
-      spiReceive();
-    }
-  }
-  spiStop();
-  spiSetSckSpeed(spiConfig.maxSck);
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::cardCMD6(uint32_t arg, uint8_t* status) {
-  if (cardCommand(CMD6, arg)) {
-    error(SD_CARD_ERROR_CMD6);
-    goto fail;
-  }
-  if (!readData(status, 64)) {
-    goto fail;
-  }
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-// send command and return error code.  Return zero for OK
-uint8_t SharedSpiCard::cardCommand(uint8_t cmd, uint32_t arg) {
-  if (!syncDevice()) {
-    return 0XFF;
-  }
-  // select card
-  if (!m_spiActive) {
-    spiStart();
-  }
-  if (cmd != CMD0 && cmd != CMD12 && !waitReady(SD_CMD_TIMEOUT)) {
-    return 0XFF;
-  }
-#if USE_SD_CRC
-  // form message
-  uint8_t buf[6];
-  buf[0] = (uint8_t)0x40U | cmd;
-  buf[1] = (uint8_t)(arg >> 24U);
-  buf[2] = (uint8_t)(arg >> 16U);
-  buf[3] = (uint8_t)(arg >> 8U);
-  buf[4] = (uint8_t)arg;
-
-  // add CRC
-  buf[5] = CRC7(buf, 5);
-
-  // send message
-  spiSend(buf, 6);
-#else  // USE_SD_CRC
-  // send command
-  spiSend(cmd | 0x40);
-
-  // send argument
-  uint8_t* pa = reinterpret_cast<uint8_t*>(&arg);
-  for (int8_t i = 3; i >= 0; i--) {
-    spiSend(pa[i]);
-  }
-
-  // send CRC - correct for CMD0 with arg zero or CMD8 with arg 0X1AA
-  spiSend(cmd == CMD0 ? 0X95 : 0X87);
-#endif  // USE_SD_CRC
-
-  // discard first fill byte to avoid MISO pull-up problem.
-  spiReceive();
-
-  // there are 1-8 fill bytes before response.  fill bytes should be 0XFF.
-  uint16_t n = 0;
-  do {
-    m_status = spiReceive();
-  } while (m_status & 0X80 && ++n < 10);
-  return m_status;
-}
-//------------------------------------------------------------------------------
-void SharedSpiCard::end() {
-  if (m_beginCalled) {
-    spiStop();
-    spiEnd();
-    m_beginCalled = false;
-  }
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::erase(uint32_t firstSector, uint32_t lastSector) {
-  csd_t csd;
-  if (!readCSD(&csd)) {
-    goto fail;
-  }
-  // check for single sector erase
-  if (!csd.eraseSingleBlock()) {
-    // erase size mask
-    uint8_t m = csd.eraseSize() - 1;
-    if ((firstSector & m) != 0 || ((lastSector + 1) & m) != 0) {
-      // error card can't erase specified area
-      error(SD_CARD_ERROR_ERASE_SINGLE_SECTOR);
-      goto fail;
-    }
-  }
-  if (m_type != SD_CARD_TYPE_SDHC) {
-    firstSector <<= 9;
-    lastSector <<= 9;
-  }
-  if (cardCommand(CMD32, firstSector)
-      || cardCommand(CMD33, lastSector)
-      || cardCommand(CMD38, 0)) {
-    error(SD_CARD_ERROR_ERASE);
-    goto fail;
-  }
-  if (!waitReady(SD_ERASE_TIMEOUT)) {
-    error(SD_CARD_ERROR_ERASE_TIMEOUT);
-    goto fail;
-  }
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::eraseSingleSectorEnable() {
-  csd_t csd;
-  return readCSD(&csd) ? csd.eraseSingleBlock() : false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::isBusy() {
-  if (m_state == READ_STATE) {
-    return false;
-  }
-  bool spiActive = m_spiActive;
-  if (!spiActive) {
-    spiStart();
-  }
-  bool rtn = 0XFF != spiReceive();
-  if (!spiActive) {
-    spiStop();
-  }
-  return rtn;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readData(uint8_t* dst) {
-  return readData(dst, 512);
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readData(uint8_t* dst, size_t count) {
-#if USE_SD_CRC
-  uint16_t crc;
-#endif  // USE_SD_CRC
-
-  // wait for start sector token
-  Timeout timeout(SD_READ_TIMEOUT);
-  while ((m_status = spiReceive()) == 0XFF) {
-    if (timeout.timedOut()) {
-      error(SD_CARD_ERROR_READ_TIMEOUT);
-      goto fail;
-    }
-  }
-  if (m_status != DATA_START_SECTOR) {
-    error(SD_CARD_ERROR_READ_TOKEN);
-    goto fail;
-  }
-  // transfer data
-  if ((m_status = spiReceive(dst, count))) {
-    error(SD_CARD_ERROR_DMA);
-    goto fail;
-  }
-
-#if USE_SD_CRC
-  // get crc
-  crc = (spiReceive() << 8) | spiReceive();
-  if (crc != CRC_CCITT(dst, count)) {
-    error(SD_CARD_ERROR_READ_CRC);
-    goto fail;
-  }
-#else  // USE_SD_CRC
-  // discard crc
-  spiReceive();
-  spiReceive();
-#endif  // USE_SD_CRC
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readOCR(uint32_t* ocr) {
-  uint8_t* p = reinterpret_cast<uint8_t*>(ocr);
-  if (cardCommand(CMD58, 0)) {
-    error(SD_CARD_ERROR_CMD58);
-    goto fail;
-  }
-  for (uint8_t i = 0; i < 4; i++) {
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    p[3 - i] = spiReceive();
-#else  // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    p[i] = spiReceive();
-#endif  // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-  }
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-/** read CID or CSR register */
-bool SharedSpiCard::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;
-  }
-  if (!readData(dst, 16)) {
-    goto fail;
-  }
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readSCR(scr_t* scr) {
-  uint8_t* dst = reinterpret_cast<uint8_t*>(scr);
-  if (cardAcmd(ACMD51, 0)) {
-    error(SD_CARD_ERROR_ACMD51);
-    goto fail;
-  }
-  if (!readData(dst, sizeof(scr_t))) {
-    goto fail;
-  }
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readSector(uint32_t sector, uint8_t* dst) {
-  // use address if not SDHC card
-  if (type() != SD_CARD_TYPE_SDHC) {
-    sector <<= 9;
-  }
-  if (cardCommand(CMD17, sector)) {
-    error(SD_CARD_ERROR_CMD17);
-    goto fail;
-  }
-  if (!readData(dst, 512)) {
-    goto fail;
-  }
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readSectors(uint32_t sector, uint8_t* dst, size_t ns) {
-  if (!readStart(sector)) {
-    goto fail;
-  }
-  for (size_t i = 0; i < ns; i++, dst += 512) {
-    if (!readData(dst, 512)) {
-      goto fail;
-    }
-  }
-  return readStop();
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readStart(uint32_t sector) {
-  if (type() != SD_CARD_TYPE_SDHC) {
-    sector <<= 9;
-  }
-  if (cardCommand(CMD18, sector)) {
-    error(SD_CARD_ERROR_CMD18);
-    goto fail;
-  }
-  m_state = READ_STATE;
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readStatus(SdStatus* status) {
-  uint8_t* dst = reinterpret_cast<uint8_t*>(status);
-  // retrun is R2 so read extra status byte.
-  if (cardAcmd(ACMD13, 0) || spiReceive()) {
-    error(SD_CARD_ERROR_ACMD13);
-    goto fail;
-  }
-  if (!readData(dst, 64)) {
-    goto fail;
-  }
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::readStop() {
-  m_state = IDLE_STATE;
-  if (cardCommand(CMD12, 0)) {
-    error(SD_CARD_ERROR_CMD12);
-    goto fail;
-  }
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-uint32_t SharedSpiCard::sectorCount() {
-  csd_t csd;
-  return readCSD(&csd) ? csd.capacity() : 0;
-}
-//------------------------------------------------------------------------------
-void SharedSpiCard::spiStart() {
-  if (!m_spiActive) {
-    spiActivate();
-    m_spiActive = true;
-    spiSelect();
-    // Dummy byte to drive MISO busy status.
-    spiSend(0XFF);
-  }
-}
-//------------------------------------------------------------------------------
-void SharedSpiCard::spiStop() {
-  if (m_spiActive) {
-    spiUnselect();
-    // Insure MISO goes to low Z.
-    spiSend(0XFF);
-    spiDeactivate();
-    m_spiActive = false;
-  }
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::syncDevice() {
-  if (m_state == WRITE_STATE) {
-    return writeStop();
-  }
-  if (m_state == READ_STATE) {
-    return readStop();
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::waitReady(uint16_t ms) {
-  Timeout timeout(ms);
-  while (spiReceive() != 0XFF) {
-    if (timeout.timedOut()) {
-      return false;
-    }
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::writeData(const uint8_t* src) {
-  // wait for previous write to finish
-  if (!waitReady(SD_WRITE_TIMEOUT)) {
-    error(SD_CARD_ERROR_WRITE_TIMEOUT);
-    goto fail;
-  }
-  if (!writeData(WRITE_MULTIPLE_TOKEN, src)) {
-    goto fail;
-  }
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-// send one sector of data for write sector or write multiple sectors
-bool SharedSpiCard::writeData(uint8_t token, const uint8_t* src) {
-#if USE_SD_CRC
-  uint16_t crc = CRC_CCITT(src, 512);
-#else  // USE_SD_CRC
-  uint16_t crc = 0XFFFF;
-#endif  // USE_SD_CRC
-  spiSend(token);
-  spiSend(src, 512);
-  spiSend(crc >> 8);
-  spiSend(crc & 0XFF);
-
-  m_status = spiReceive();
-  if ((m_status & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
-    error(SD_CARD_ERROR_WRITE_DATA);
-    goto fail;
-  }
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::writeSector(uint32_t sector, const uint8_t* src) {
-  // use address if not SDHC card
-  if (type() != SD_CARD_TYPE_SDHC) {
-    sector <<= 9;
-  }
-  if (cardCommand(CMD24, sector)) {
-    error(SD_CARD_ERROR_CMD24);
-    goto fail;
-  }
-  if (!writeData(DATA_START_SECTOR, src)) {
-    goto fail;
-  }
-
-#if CHECK_FLASH_PROGRAMMING
-  // wait for flash programming to complete
-  if (!waitReady(SD_WRITE_TIMEOUT)) {
-    error(SD_CARD_ERROR_WRITE_PROGRAMMING);
-    goto fail;
-  }
-  // response is r2 so get and check two bytes for nonzero
-  if (cardCommand(CMD13, 0) || spiReceive()) {
-    error(SD_CARD_ERROR_CMD13);
-    goto fail;
-  }
-#endif  // CHECK_FLASH_PROGRAMMING
-
-  spiStop();
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::writeSectors(uint32_t sector,
-                                 const uint8_t* src, size_t ns) {
-  if (!writeStart(sector)) {
-    goto fail;
-  }
-  for (size_t i = 0; i < ns; i++, src += 512) {
-    if (!writeData(src)) {
-      goto fail;
-    }
-  }
-  return writeStop();
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::writeStart(uint32_t sector) {
-  // use address if not SDHC card
-  if (type() != SD_CARD_TYPE_SDHC) {
-    sector <<= 9;
-  }
-  if (cardCommand(CMD25, sector)) {
-    error(SD_CARD_ERROR_CMD25);
-    goto fail;
-  }
-  m_state = WRITE_STATE;
-  return true;
-
- fail:
-  spiStop();
-  return false;
-}
-//------------------------------------------------------------------------------
-bool SharedSpiCard::writeStop() {
-  if (!waitReady(SD_WRITE_TIMEOUT)) {
-    goto fail;
-  }
-  spiSend(STOP_TRAN_TOKEN);
-  spiStop();
-  m_state = IDLE_STATE;
-  return true;
-
- fail:
-  error(SD_CARD_ERROR_STOP_TRAN);
-  spiStop();
-  return false;
-}
-//==============================================================================
-bool DedicatedSpiCard::begin(SdSpiConfig spiConfig) {
-  if (!SharedSpiCard::begin(spiConfig)) {
-    return false;
-  }
-  m_dedicatedSpi = spiOptionDedicated(spiConfig.options);
-  return true;
-}
-//------------------------------------------------------------------------------
-bool DedicatedSpiCard::readSector(uint32_t sector, uint8_t* dst) {
-  return readSectors(sector, dst, 1);
-}
-//------------------------------------------------------------------------------
-bool DedicatedSpiCard::readSectors(
-    uint32_t sector, uint8_t* dst, size_t ns) {
-  if (sdState() != READ_STATE || sector != m_curSector) {
-    if (!readStart(sector)) {
-      goto fail;
-    }
-    m_curSector = sector;
-  }
-  for (size_t i = 0; i < ns; i++, dst += 512) {
-    if (!readData(dst)) {
-      goto fail;
-    }
-  }
-  m_curSector += ns;
-  return m_dedicatedSpi ? true : readStop();
-
- fail:
-  return false;
-}
-//------------------------------------------------------------------------------
-bool DedicatedSpiCard::setDedicatedSpi(bool value) {
-  if (!syncDevice()) {
-    return false;
-  }
-  m_dedicatedSpi = value;
-  return true;
-}
-//------------------------------------------------------------------------------
-bool DedicatedSpiCard::writeSector(uint32_t sector, const uint8_t* src) {
-  if (m_dedicatedSpi) {
-    return writeSectors(sector, src, 1);
-  }
-  return SharedSpiCard::writeSector(sector, src);
-}
-//------------------------------------------------------------------------------
-bool DedicatedSpiCard::writeSectors(
-    uint32_t sector, const uint8_t* src, size_t ns) {
-  if (sdState() != WRITE_STATE || m_curSector != sector) {
-    if (!writeStart(sector)) {
-      goto fail;
-    }
-    m_curSector = sector;
-  }
-  for (size_t i = 0; i < ns; i++, src += 512) {
-    if (!writeData(src)) {
-      goto fail;
-    }
-  }
-  m_curSector += ns;
-  return m_dedicatedSpi ? true : writeStop();
-
-fail:
-  return false;
-}

lib/SdFat_NoArduino/src/SdCard/SdSpiCard.h

@@ -1,451 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief SdSpiCard class for V2 SD/SDHC cards
- */
-#ifndef SdSpiCard_h
-#define SdSpiCard_h
-#include <stddef.h>
-#include "../common/SysCall.h"
-#include "SdCardInfo.h"
-#include "SdCardInterface.h"
-#include "../SpiDriver/SdSpiDriver.h"
-/** Verify correct SPI active if non-zero. */
-#define CHECK_SPI_ACTIVE 0
-#if CHECK_SPI_ACTIVE
-/** Check SPI active. */
-#define SPI_ASSERT_ACTIVE {if (!m_spiActive) {\
-  Serial.print(F("SPI_ASSERTACTIVE"));\
-  Serial.println(__LINE__);}}
-#else  // CHECK_SPI_ACTIVE
-/** Do not check SPI active. */
-#define SPI_ASSERT_ACTIVE
-#endif  // CHECK_SPI_ACTIVE
-//==============================================================================
-/**
- * \class SharedSpiCard
- * \brief Raw access to SD and SDHC flash memory cards via shared SPI port.
- */
-#if HAS_SDIO_CLASS
-class SharedSpiCard : public SdCardInterface {
-#elif USE_BLOCK_DEVICE_INTERFACE
-class SharedSpiCard : public FsBlockDeviceInterface {
-#else  // HAS_SDIO_CLASS
-class SharedSpiCard {
-#endif  // HAS_SDIO_CLASS
- public:
-  /** SD is in idle state */
-  static const uint8_t IDLE_STATE = 0;
-  /** SD is in multi-sector read state. */
-  static const uint8_t READ_STATE = 1;
-  /** SD is in multi-sector write state. */
-  static const uint8_t WRITE_STATE = 2;
-  /** Construct an instance of SharedSpiCard. */
-  SharedSpiCard() {}
-  /** Initialize the SD card.
-   * \param[in] spiConfig SPI card configuration.
-   * \return true for success or false for failure.
-   */
-  bool begin(SdSpiConfig spiConfig);
-  /** CMD6 Switch mode: Check Function Set Function.
-   * \param[in] arg CMD6 argument.
-   * \param[out] status return status data.
-   *
-   * \return true for success or false for failure.
-   */
-  bool cardCMD6(uint32_t arg, uint8_t* status);
-  /** End use of card */
-  void end();
-  /** Erase a range of sectors.
-   *
-   * \param[in] firstSector The address of the first sector in the range.
-   * \param[in] lastSector The address of the last sector in the range.
-   *
-   * \note This function requests the SD card to do a flash erase for a
-   * range of sectors.  The data on the card after an erase operation is
-   * either 0 or 1, depends on the card vendor.  The card must support
-   * single sector erase.
-   *
-   * \return true for success or false for failure.
-   */
-  bool erase(uint32_t firstSector, uint32_t lastSector);
-  /** Determine if card supports single sector erase.
-   *
-   * \return true is returned if single sector erase is supported.
-   * false is returned if single sector erase is not supported.
-   */
-  bool eraseSingleSectorEnable();
-  /**
-   *  Set SD error code.
-   *  \param[in] code value for error code.
-   */
-  void error(uint8_t code) {
-//    (void)code;
-    m_errorCode = code;
-  }
-  /**
-   * \return code for the last error. See SdCardInfo.h for a list of error codes.
-   */
-  uint8_t errorCode() const {
-    return m_errorCode;
-  }
-  /** \return error data for last error. */
-  uint32_t errorData() const {
-    return m_status;
-  }
-  /** \return false for shared class. */
-  bool hasDedicatedSpi() {return false;}
-  /**
-   * Check for busy.  MISO low indicates the card is busy.
-   *
-   * \return true if busy else false.
-   */
-  bool isBusy();
-  /** \return false, can't be in dedicated state. */
-  bool isDedicatedSpi() {return false;}
-  /**
-   * Read a card's CID register. The CID contains card identification
-   * information such as Manufacturer ID, Product name, Product serial
-   * number and Manufacturing date.
-   *
-   * \param[out] cid pointer to area for returned data.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readCID(cid_t* cid) {
-    return readRegister(CMD10, cid);
-  }
-  /**
-   * Read a card's CSD register. The CSD contains Card-Specific Data that
-   * provides information regarding access to the card's contents.
-   *
-   * \param[out] csd pointer to area for returned data.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readCSD(csd_t* csd) {
-    return readRegister(CMD9, csd);
-  }
-  /** Read one data sector in a multiple sector read sequence
-   *
-   * \param[out] dst Pointer to the location for the data to be read.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readData(uint8_t* dst);
-  /** Read OCR register.
-   *
-   * \param[out] ocr Value of OCR register.
-   * \return true for success or false for failure.
-   */
-  bool readOCR(uint32_t* ocr);
-  /** Read SCR register.
-   *
-   * \param[out] scr Value of SCR register.
-   * \return true for success or false for failure.
-   */
-  bool readSCR(scr_t* scr);
-  /**
-   * Read a 512 byte sector from an SD card.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  bool readSector(uint32_t sector, uint8_t* dst);
-  /**
-   * Read multiple 512 byte sectors from an SD card.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[in] ns Number of sectors to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  bool readSectors(uint32_t sector, uint8_t* dst, size_t ns);
-
-  /** Start a read multiple sector sequence.
-   *
-   * \param[in] sector Address of first sector in sequence.
-   *
-   * \note This function is used with readData() and readStop() for optimized
-   * multiple sector reads.  SPI chipSelect must be low for the entire sequence.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readStart(uint32_t sector);
-  /** Return the 64 byte card status
-   * \param[out] status location for 64 status bytes.
-   * \return true for success or false for failure.
-   */
-  bool readStatus(SdStatus* status);
-  /** End a read multiple sectors sequence.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readStop();
-  /** \return SD multi-sector read/write state */
-  uint8_t sdState() {return m_state;}
-  /**
-   * Determine the size of an SD flash memory card.
-   *
-   * \return The number of 512 byte data sectors in the card
-   *         or zero if an error occurs.
-   */
-  uint32_t sectorCount();
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  // Use sectorCount(). cardSize() will be removed in the future.
-  uint32_t __attribute__((error("use sectorCount()"))) cardSize();
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  /** Set SPI sharing state
-   * \param[in] value desired state.
-   * \return false for shared card
-   */
-  bool setDedicatedSpi(bool value) {
-    (void)value;
-    return false;
-  }
-  /** end a mult-sector transfer.
-   *
-   * \return true for success or false for failure.
-   */
-  bool stopTransfer();
-  /** \return success if sync successful. Not for user apps. */
-  bool syncDevice();
-  /** Return the card type: SD V1, SD V2 or SDHC/SDXC
-   * \return 0 - SD V1, 1 - SD V2, or 3 - SDHC/SDXC.
-   */
-  uint8_t type() const {
-    return m_type;
-  }
-  /**
-   * Write a 512 byte sector to an SD card.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool writeSector(uint32_t sector, const uint8_t* src);
-  /**
-   * Write multiple 512 byte sectors to an SD card.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] ns Number of sectors to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool writeSectors(uint32_t sector, const uint8_t* src, size_t ns);
-  /** Write one data sector in a multiple sector write sequence.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool writeData(const uint8_t* src);
-  /** Start a write multiple sectors sequence.
-   *
-   * \param[in] sector Address of first sector in sequence.
-   *
-   * \note This function is used with writeData() and writeStop()
-   * for optimized multiple sector writes.
-   *
-   * \return true for success or false for failure.
-   */
-  bool writeStart(uint32_t sector);
-
-  /** End a write multiple sectors sequence.
-   *
-   * \return true for success or false for failure.
-   */
-  bool writeStop();
-
- private:
-  // private functions
-  uint8_t cardAcmd(uint8_t cmd, uint32_t arg) {
-    cardCommand(CMD55, 0);
-    return cardCommand(cmd, arg);
-  }
-  uint8_t cardCommand(uint8_t cmd, uint32_t arg);
-  bool readData(uint8_t* dst, size_t count);
-  bool readRegister(uint8_t cmd, void* buf);
-  void spiSelect() {
-    sdCsWrite(m_csPin, false);
-  }
-  void spiStart();
-  void spiStop();
-  void spiUnselect() {
-    sdCsWrite(m_csPin, true);
-  }
-  void type(uint8_t value) {
-    m_type = value;
-  }
-  bool waitReady(uint16_t ms);
-  bool writeData(uint8_t token, const uint8_t* src);
-#if SPI_DRIVER_SELECT < 2
-  void spiActivate() {
-    m_spiDriver.activate();
-  }
-  void spiBegin(SdSpiConfig spiConfig) {
-    m_spiDriver.begin(spiConfig);
-  }
-  void spiDeactivate() {
-    m_spiDriver.deactivate();
-  }
-  void spiEnd() {
-    m_spiDriver.end();
-  }
-  uint8_t spiReceive() {
-    SPI_ASSERT_ACTIVE;
-    return m_spiDriver.receive();
-  }
-  uint8_t spiReceive(uint8_t* buf, size_t n) {
-    SPI_ASSERT_ACTIVE;
-    return m_spiDriver.receive(buf, n);
-  }
-  void spiSend(uint8_t data) {
-    SPI_ASSERT_ACTIVE;
-    m_spiDriver.send(data);
-  }
-  void spiSend(const uint8_t* buf, size_t n) {
-    SPI_ASSERT_ACTIVE;
-    m_spiDriver.send(buf, n);
-  }
-  void spiSetSckSpeed(uint32_t maxSck) {
-    m_spiDriver.setSckSpeed(maxSck);
-  }
-  SdSpiDriver m_spiDriver;
-#else  // SPI_DRIVER_SELECT < 2
-  void spiActivate() {
-    m_spiDriverPtr->activate();
-  }
-  void spiBegin(SdSpiConfig spiConfig) {
-    m_spiDriverPtr->begin(spiConfig);
-  }
-  void spiDeactivate() {
-    m_spiDriverPtr->deactivate();
-  }
-  void spiEnd() {
-    m_spiDriverPtr->end();
-  }
-  uint8_t spiReceive() {
-    SPI_ASSERT_ACTIVE;
-    return m_spiDriverPtr->receive();
-  }
-  uint8_t spiReceive(uint8_t* buf, size_t n) {
-    SPI_ASSERT_ACTIVE;
-    return m_spiDriverPtr->receive(buf, n);
-  }
-  void spiSend(uint8_t data) {
-    SPI_ASSERT_ACTIVE;
-    m_spiDriverPtr->send(data);
-  }
-  void spiSend(const uint8_t* buf, size_t n) {
-    SPI_ASSERT_ACTIVE;
-    m_spiDriverPtr->send(buf, n);
-  }
-  void spiSetSckSpeed(uint32_t maxSck) {
-    m_spiDriverPtr->setSckSpeed(maxSck);
-  }
-  SdSpiDriver* m_spiDriverPtr;
-
-#endif  // SPI_DRIVER_SELECT < 2
-  bool m_beginCalled = false;
-  SdCsPin_t m_csPin;
-  uint8_t m_errorCode = SD_CARD_ERROR_INIT_NOT_CALLED;
-  bool    m_spiActive;
-  uint8_t m_state;
-  uint8_t m_status;
-  uint8_t m_type = 0;
-};
-
-//==============================================================================
-/**
- * \class DedicatedSpiCard
- * \brief Raw access to SD and SDHC flash memory cards via dedicate SPI port.
- */
-class DedicatedSpiCard : public SharedSpiCard {
- public:
-  /** Construct an instance of DedicatedSpiCard. */
-  DedicatedSpiCard() {}
-  /** Initialize the SD card.
-   * \param[in] spiConfig SPI card configuration.
-   * \return true for success or false for failure.
-   */
-  bool begin(SdSpiConfig spiConfig);
-  /** \return true, can be in dedicaded state. */
-  bool hasDedicatedSpi() {return true;}
-  /** \return true if in dedicated SPI state. */
-  bool isDedicatedSpi() {return m_dedicatedSpi;}
-  /**
-   * Read a 512 byte sector from an SD card.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  bool readSector(uint32_t sector, uint8_t* dst);
-  /**
-   * Read multiple 512 byte sectors from an SD card.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[in] ns Number of sectors to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  bool readSectors(uint32_t sector, uint8_t* dst, size_t ns);
-  /** Set SPI sharing state
-   * \param[in] value desired state.
-   * \return true for success else false;
-   */
-  bool setDedicatedSpi(bool value);
-  /**
-   * Write a 512 byte sector to an SD card.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool writeSector(uint32_t sector, const uint8_t* src);
-  /**
-   * Write multiple 512 byte sectors to an SD card.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] ns Number of sectors to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool writeSectors(uint32_t sector, const uint8_t* src, size_t ns);
-
- private:
-  uint32_t m_curSector;
-  bool m_dedicatedSpi = false;
-};
-//==============================================================================
-#if ENABLE_DEDICATED_SPI
-/** typedef for dedicated SPI. */
-typedef DedicatedSpiCard SdSpiCard;
-#else
-/** typedef for shared SPI. */
-typedef SharedSpiCard SdSpiCard;
-#endif
-#endif  // SdSpiCard_h

lib/SdFat_NoArduino/src/SdCard/SdioCard.h

@@ -1,267 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef SdioCard_h
-#define SdioCard_h
-#include "../common/SysCall.h"
-#include "SdCardInterface.h"
-
-#define FIFO_SDIO 0
-#define DMA_SDIO 1
-/**
- * \class SdioConfig
- * \brief SDIO card configuration.
- */
-class SdioConfig {
- public:
-  SdioConfig() {}
-  /**
-   * SdioConfig constructor.
-   * \param[in] opt SDIO options.
-   */
-  explicit SdioConfig(uint8_t opt) : m_options(opt) {}
-  /** \return SDIO card options. */
-  uint8_t options() {return m_options;}
-  /** \return true if DMA_SDIO. */
-  bool useDma() {return m_options & DMA_SDIO;}
- private:
-  uint8_t m_options = FIFO_SDIO;
-};
-//------------------------------------------------------------------------------
-/**
- * \class SdioCard
- * \brief Raw SDIO access to SD and SDHC flash memory cards.
- */
-class SdioCard : public SdCardInterface {
- public:
-  /** Initialize the SD card.
-   * \param[in] sdioConfig SDIO card configuration.
-   * \return true for success or false for failure.
-   */
-  bool begin(SdioConfig sdioConfig);
-  /** CMD6 Switch mode: Check Function Set Function.
-   * \param[in] arg CMD6 argument.
-   * \param[out] status return status data.
-   *
-   * \return true for success or false for failure.
-   */
-  bool cardCMD6(uint32_t arg, uint8_t* status);
-  /** Disable an SDIO card.
-   * not implemented.
-   */
-  void end() {}
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-    uint32_t __attribute__((error("use sectorCount()"))) cardSize();
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  /** Erase a range of sectors.
-   *
-   * \param[in] firstSector The address of the first sector in the range.
-   * \param[in] lastSector The address of the last sector in the range.
-   *
-   * \note This function requests the SD card to do a flash erase for a
-   * range of sectors.  The data on the card after an erase operation is
-   * either 0 or 1, depends on the card vendor.  The card must support
-   * single sector erase.
-   *
-   * \return true for success or false for failure.
-   */
-  bool erase(uint32_t firstSector, uint32_t lastSector);
-  /**
-   * \return code for the last error. See SdCardInfo.h for a list of error codes.
-   */
-  uint8_t errorCode() const;
-  /** \return error data for last error. */
-  uint32_t errorData() const;
-  /** \return error line for last error. Tmp function for debug. */
-  uint32_t errorLine() const;
-  /**
-   * Check for busy with CMD13.
-   *
-   * \return true if busy else false.
-   */
-  bool isBusy();
-  /** \return the SD clock frequency in kHz. */
-  uint32_t kHzSdClk();
-  /**
-   * Read a 512 byte sector from an SD card.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  bool readSector(uint32_t sector, uint8_t* dst);
-  /**
-   * Read multiple 512 byte sectors from an SD card.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[in] ns Number of sectors to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  bool readSectors(uint32_t sector, uint8_t* dst, size_t ns);
-  /**
-   * Read a card's CID register. The CID contains card identification
-   * information such as Manufacturer ID, Product name, Product serial
-   * number and Manufacturing date.
-   *
-   * \param[out] cid pointer to area for returned data.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readCID(cid_t* cid);
-  /**
-   * Read a card's CSD register. The CSD contains Card-Specific Data that
-   * provides information regarding access to the card's contents.
-   *
-   * \param[out] csd pointer to area for returned data.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readCSD(csd_t* csd);
-  /** Read one data sector in a multiple sector read sequence
-   *
-   * \param[out] dst Pointer to the location for the data to be read.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readData(uint8_t* dst);
-  /** Read OCR register.
-   *
-   * \param[out] ocr Value of OCR register.
-   * \return true for success or false for failure.
-   */
-  bool readOCR(uint32_t* ocr);
-  /** Read SCR register.
-   *
-   * \param[out] scr Value of SCR register.
-   * \return true for success or false for failure.
-   */
-  bool readSCR(scr_t *scr);
-  /** Start a read multiple sectors sequence.
-   *
-   * \param[in] sector Address of first sector in sequence.
-   *
-   * \note This function is used with readData() and readStop() for optimized
-   * multiple sector reads.  SPI chipSelect must be low for the entire sequence.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readStart(uint32_t sector);
-  /** Start a read multiple sectors sequence.
-   *
-   * \param[in] sector Address of first sector in sequence.
-   * \param[in] count Maximum sector count.
-   * \note This function is used with readData() and readStop() for optimized
-   * multiple sector reads.  SPI chipSelect must be low for the entire sequence.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readStart(uint32_t sector, uint32_t count);
-  /** End a read multiple sectors sequence.
-   *
-   * \return true for success or false for failure.
-   */
-  bool readStop();
-  /** \return SDIO card status. */
-  uint32_t status();
-    /**
-   * Determine the size of an SD flash memory card.
-   *
-   * \return The number of 512 byte data sectors in the card
-   *         or zero if an error occurs.
-   */
-  uint32_t sectorCount();
-  /**
-   *  Send CMD12 to stop read or write.
-   *
-   * \param[in] blocking If true, wait for command complete.
-   *
-   * \return true for success or false for failure.
-   */
-  bool stopTransmission(bool blocking);
-  /** \return success if sync successful. Not for user apps. */
-  bool syncDevice();
-  /** Return the card type: SD V1, SD V2 or SDHC
-   * \return 0 - SD V1, 1 - SD V2, or 3 - SDHC.
-   */
-  uint8_t type() const;
-  /**
-   * Writes a 512 byte sector to an SD card.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool writeSector(uint32_t sector, const uint8_t* src);
-  /**
-   * Write multiple 512 byte sectors to an SD card.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] ns Number of sectors to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool writeSectors(uint32_t sector, const uint8_t* src, size_t ns);
-  /** Write one data sector in a multiple sector write sequence.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool writeData(const uint8_t* src);
-  /** Start a write multiple sectors sequence.
-   *
-   * \param[in] sector Address of first sector in sequence.
-   *
-   * \note This function is used with writeData() and writeStop()
-   * for optimized multiple sector writes.
-   *
-   * \return true for success or false for failure.
-   */
-  bool writeStart(uint32_t sector);
-  /** Start a write multiple sectors sequence.
-   *
-   * \param[in] sector Address of first sector in sequence.
-   * \param[in] count Maximum sector count.
-   * \note This function is used with writeData() and writeStop()
-   * for optimized multiple sector writes.
-   *
-   * \return true for success or false for failure.
-   */
-  bool writeStart(uint32_t sector, uint32_t count);
-
-  /** End a write multiple sectors sequence.
-   *
-   * \return true for success or false for failure.
-   */
-  bool writeStop();
-
- private:
-  static const uint8_t IDLE_STATE = 0;
-  static const uint8_t READ_STATE = 1;
-  static const uint8_t WRITE_STATE = 2;
-  uint32_t m_curSector;
-  SdioConfig m_sdioConfig;
-  uint8_t m_curState = IDLE_STATE;
-};
-#endif  // SdioCard_h

lib/SdFat_NoArduino/src/SdCard/SdioTeensy.cpp

@@ -1,1120 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__) || defined(__IMXRT1062__)
-#include "SdioTeensy.h"
-#include "SdCardInfo.h"
-#include "SdioCard.h"
-//==============================================================================
-// limit of K66 due to errata KINETIS_K_0N65N.
-const uint32_t MAX_BLKCNT = 0XFFFF;
-//==============================================================================
-#define SDHC_PROCTL_DTW_4BIT 0x01
-const uint32_t FIFO_WML = 16;
-const uint32_t CMD8_RETRIES = 3;
-const uint32_t BUSY_TIMEOUT_MICROS = 1000000;
-//==============================================================================
-const uint32_t SDHC_IRQSTATEN_MASK =
-               SDHC_IRQSTATEN_DMAESEN | SDHC_IRQSTATEN_AC12ESEN |
-               SDHC_IRQSTATEN_DEBESEN | SDHC_IRQSTATEN_DCESEN |
-               SDHC_IRQSTATEN_DTOESEN | SDHC_IRQSTATEN_CIESEN |
-               SDHC_IRQSTATEN_CEBESEN | SDHC_IRQSTATEN_CCESEN |
-               SDHC_IRQSTATEN_CTOESEN | SDHC_IRQSTATEN_DINTSEN |
-               SDHC_IRQSTATEN_TCSEN | SDHC_IRQSTATEN_CCSEN;
-
-const uint32_t SDHC_IRQSTAT_CMD_ERROR =
-               SDHC_IRQSTAT_CIE | SDHC_IRQSTAT_CEBE |
-               SDHC_IRQSTAT_CCE | SDHC_IRQSTAT_CTOE;
-
-const uint32_t SDHC_IRQSTAT_DATA_ERROR =
-               SDHC_IRQSTAT_AC12E | SDHC_IRQSTAT_DEBE |
-               SDHC_IRQSTAT_DCE | SDHC_IRQSTAT_DTOE;
-
-const uint32_t SDHC_IRQSTAT_ERROR =
-               SDHC_IRQSTAT_DMAE | SDHC_IRQSTAT_CMD_ERROR |
-               SDHC_IRQSTAT_DATA_ERROR;
-
-const uint32_t SDHC_IRQSIGEN_MASK =
-               SDHC_IRQSIGEN_DMAEIEN | SDHC_IRQSIGEN_AC12EIEN |
-               SDHC_IRQSIGEN_DEBEIEN | SDHC_IRQSIGEN_DCEIEN |
-               SDHC_IRQSIGEN_DTOEIEN | SDHC_IRQSIGEN_CIEIEN |
-               SDHC_IRQSIGEN_CEBEIEN | SDHC_IRQSIGEN_CCEIEN |
-               SDHC_IRQSIGEN_CTOEIEN | SDHC_IRQSIGEN_TCIEN;
-//==============================================================================
-const uint32_t CMD_RESP_NONE = SDHC_XFERTYP_RSPTYP(0);
-
-const uint32_t CMD_RESP_R1 = SDHC_XFERTYP_CICEN | SDHC_XFERTYP_CCCEN |
-                             SDHC_XFERTYP_RSPTYP(2);
-
-const uint32_t CMD_RESP_R1b = SDHC_XFERTYP_CICEN | SDHC_XFERTYP_CCCEN |
-                              SDHC_XFERTYP_RSPTYP(3);
-
-const uint32_t CMD_RESP_R2 = SDHC_XFERTYP_CCCEN | SDHC_XFERTYP_RSPTYP(1);
-
-const uint32_t CMD_RESP_R3 = SDHC_XFERTYP_RSPTYP(2);
-
-const uint32_t CMD_RESP_R6 = CMD_RESP_R1;
-
-const uint32_t CMD_RESP_R7 = CMD_RESP_R1;
-
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-const uint32_t DATA_READ = SDHC_XFERTYP_DTDSEL | SDHC_XFERTYP_DPSEL;
-
-const uint32_t DATA_READ_DMA = DATA_READ | SDHC_XFERTYP_DMAEN;
-
-const uint32_t DATA_READ_MULTI_DMA = DATA_READ_DMA | SDHC_XFERTYP_MSBSEL |
-                                     SDHC_XFERTYP_AC12EN | SDHC_XFERTYP_BCEN;
-
-const uint32_t DATA_READ_MULTI_PGM = DATA_READ | SDHC_XFERTYP_MSBSEL |
-                                     SDHC_XFERTYP_BCEN;
-
-const uint32_t DATA_WRITE_DMA = SDHC_XFERTYP_DPSEL | SDHC_XFERTYP_DMAEN;
-
-const uint32_t DATA_WRITE_MULTI_DMA = DATA_WRITE_DMA | SDHC_XFERTYP_MSBSEL |
-                                      SDHC_XFERTYP_AC12EN | SDHC_XFERTYP_BCEN;
-
-const uint32_t DATA_WRITE_MULTI_PGM = SDHC_XFERTYP_DPSEL | SDHC_XFERTYP_MSBSEL |
-                                      SDHC_XFERTYP_BCEN;
-
-#elif defined(__IMXRT1062__)
-// Use low bits for SDHC_MIX_CTRL since bits 15-0 of SDHC_XFERTYP are reserved.
-const uint32_t SDHC_MIX_CTRL_MASK = SDHC_MIX_CTRL_DMAEN | SDHC_MIX_CTRL_BCEN |
-                                    SDHC_MIX_CTRL_AC12EN |
-                                    SDHC_MIX_CTRL_DDR_EN |
-                                    SDHC_MIX_CTRL_DTDSEL |
-                                    SDHC_MIX_CTRL_MSBSEL |
-                                    SDHC_MIX_CTRL_NIBBLE_POS |
-                                    SDHC_MIX_CTRL_AC23EN;
-
-const uint32_t DATA_READ = SDHC_MIX_CTRL_DTDSEL | SDHC_XFERTYP_DPSEL;
-
-const uint32_t DATA_READ_DMA = DATA_READ | SDHC_MIX_CTRL_DMAEN;
-
-const uint32_t DATA_READ_MULTI_DMA = DATA_READ_DMA | SDHC_MIX_CTRL_MSBSEL |
-                                     SDHC_MIX_CTRL_AC12EN | SDHC_MIX_CTRL_BCEN;
-
-const uint32_t DATA_READ_MULTI_PGM = DATA_READ | SDHC_MIX_CTRL_MSBSEL;
-
-
-const uint32_t DATA_WRITE_DMA = SDHC_XFERTYP_DPSEL | SDHC_MIX_CTRL_DMAEN;
-
-const uint32_t DATA_WRITE_MULTI_DMA = DATA_WRITE_DMA | SDHC_MIX_CTRL_MSBSEL |
-                                      SDHC_MIX_CTRL_AC12EN | SDHC_MIX_CTRL_BCEN;
-
-const uint32_t DATA_WRITE_MULTI_PGM = SDHC_XFERTYP_DPSEL | SDHC_MIX_CTRL_MSBSEL;
-
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-
-const uint32_t ACMD6_XFERTYP = SDHC_XFERTYP_CMDINX(ACMD6) | CMD_RESP_R1;
-
-const uint32_t ACMD41_XFERTYP = SDHC_XFERTYP_CMDINX(ACMD41) | CMD_RESP_R3;
-
-const uint32_t ACMD51_XFERTYP = SDHC_XFERTYP_CMDINX(ACMD51) | CMD_RESP_R1 |
-                                DATA_READ_DMA;
-
-const uint32_t CMD0_XFERTYP = SDHC_XFERTYP_CMDINX(CMD0) | CMD_RESP_NONE;
-
-const uint32_t CMD2_XFERTYP = SDHC_XFERTYP_CMDINX(CMD2) | CMD_RESP_R2;
-
-const uint32_t CMD3_XFERTYP = SDHC_XFERTYP_CMDINX(CMD3) | CMD_RESP_R6;
-
-const uint32_t CMD6_XFERTYP = SDHC_XFERTYP_CMDINX(CMD6) | CMD_RESP_R1 |
-                              DATA_READ_DMA;
-
-const uint32_t CMD7_XFERTYP = SDHC_XFERTYP_CMDINX(CMD7) | CMD_RESP_R1b;
-
-const uint32_t CMD8_XFERTYP = SDHC_XFERTYP_CMDINX(CMD8) | CMD_RESP_R7;
-
-const uint32_t CMD9_XFERTYP = SDHC_XFERTYP_CMDINX(CMD9) | CMD_RESP_R2;
-
-const uint32_t CMD10_XFERTYP = SDHC_XFERTYP_CMDINX(CMD10) | CMD_RESP_R2;
-
-const uint32_t CMD11_XFERTYP = SDHC_XFERTYP_CMDINX(CMD11) | CMD_RESP_R1;
-
-const uint32_t CMD12_XFERTYP = SDHC_XFERTYP_CMDINX(CMD12) | CMD_RESP_R1b |
-                               SDHC_XFERTYP_CMDTYP(3);
-
-const uint32_t CMD13_XFERTYP = SDHC_XFERTYP_CMDINX(CMD13) | CMD_RESP_R1;
-
-const uint32_t CMD17_DMA_XFERTYP = SDHC_XFERTYP_CMDINX(CMD17) | CMD_RESP_R1 |
-                                   DATA_READ_DMA;
-
-const uint32_t CMD18_DMA_XFERTYP = SDHC_XFERTYP_CMDINX(CMD18) | CMD_RESP_R1 |
-                                   DATA_READ_MULTI_DMA;
-
-const uint32_t CMD18_PGM_XFERTYP = SDHC_XFERTYP_CMDINX(CMD18) | CMD_RESP_R1 |
-                                   DATA_READ_MULTI_PGM;
-
-const uint32_t CMD24_DMA_XFERTYP = SDHC_XFERTYP_CMDINX(CMD24) | CMD_RESP_R1 |
-                                   DATA_WRITE_DMA;
-
-const uint32_t CMD25_DMA_XFERTYP = SDHC_XFERTYP_CMDINX(CMD25) | CMD_RESP_R1 |
-                                   DATA_WRITE_MULTI_DMA;
-
-const uint32_t CMD25_PGM_XFERTYP = SDHC_XFERTYP_CMDINX(CMD25) | CMD_RESP_R1 |
-                                   DATA_WRITE_MULTI_PGM;
-
-const uint32_t CMD32_XFERTYP = SDHC_XFERTYP_CMDINX(CMD32) | CMD_RESP_R1;
-
-const uint32_t CMD33_XFERTYP = SDHC_XFERTYP_CMDINX(CMD33) | CMD_RESP_R1;
-
-const uint32_t CMD38_XFERTYP = SDHC_XFERTYP_CMDINX(CMD38) | CMD_RESP_R1b;
-
-const uint32_t CMD55_XFERTYP = SDHC_XFERTYP_CMDINX(CMD55) | CMD_RESP_R1;
-
-//==============================================================================
-static bool cardCommand(uint32_t xfertyp, uint32_t arg);
-static void enableGPIO(bool enable);
-static void enableDmaIrs();
-static void initSDHC();
-static bool isBusyCMD13();
-static bool isBusyCommandComplete();
-static bool isBusyCommandInhibit();
-static bool readReg16(uint32_t xfertyp, void* data);
-static void setSdclk(uint32_t kHzMax);
-static bool yieldTimeout(bool (*fcn)());
-static bool waitDmaStatus();
-static bool waitTimeout(bool (*fcn)());
-//------------------------------------------------------------------------------
-static bool (*m_busyFcn)() = 0;
-static bool m_initDone = false;
-static bool m_version2;
-static bool m_highCapacity;
-static bool m_transferActive = false;
-static uint8_t m_errorCode = SD_CARD_ERROR_INIT_NOT_CALLED;
-static uint32_t m_errorLine = 0;
-static uint32_t m_rca;
-static volatile bool m_dmaBusy = false;
-static volatile uint32_t m_irqstat;
-static uint32_t m_sdClkKhz = 0;
-static uint32_t m_ocr;
-static cid_t m_cid;
-static csd_t m_csd;
-static scr_t m_scr;
-//==============================================================================
-#define DBG_TRACE Serial.print("TRACE."); Serial.println(__LINE__); delay(200);
-#define USE_DEBUG_MODE 0
-#if USE_DEBUG_MODE
-#define DBG_IRQSTAT() if (SDHC_IRQSTAT) {Serial.print(__LINE__);\
-        Serial.print(" IRQSTAT "); Serial.println(SDHC_IRQSTAT, HEX);}
-static void printRegs(uint32_t line) {
-  uint32_t blkattr = SDHC_BLKATTR;
-  uint32_t xfertyp = SDHC_XFERTYP;
-  uint32_t prsstat = SDHC_PRSSTAT;
-  uint32_t proctl = SDHC_PROCTL;
-  uint32_t irqstat = SDHC_IRQSTAT;
-  Serial.print("\nLINE: ");
-  Serial.println(line);
-  Serial.print("BLKATTR ");
-  Serial.println(blkattr, HEX);
-  Serial.print("XFERTYP ");
-  Serial.print(xfertyp, HEX);
-  Serial.print(" CMD");
-  Serial.print(xfertyp >> 24);
-  Serial.print(" TYP");
-  Serial.print((xfertyp >> 2) & 3);
-  if (xfertyp & SDHC_XFERTYP_DPSEL) {Serial.print(" DPSEL");}
-  Serial.println();
-  Serial.print("PRSSTAT ");
-  Serial.print(prsstat, HEX);
-  if (prsstat & SDHC_PRSSTAT_BREN) {Serial.print(" BREN");}
-  if (prsstat & SDHC_PRSSTAT_BWEN) {Serial.print(" BWEN");}
-  if (prsstat & SDHC_PRSSTAT_RTA) {Serial.print(" RTA");}
-  if (prsstat & SDHC_PRSSTAT_WTA) {Serial.print(" WTA");}
-  if (prsstat & SDHC_PRSSTAT_SDOFF) {Serial.print(" SDOFF");}
-  if (prsstat & SDHC_PRSSTAT_PEROFF) {Serial.print(" PEROFF");}
-  if (prsstat & SDHC_PRSSTAT_HCKOFF) {Serial.print(" HCKOFF");}
-  if (prsstat & SDHC_PRSSTAT_IPGOFF) {Serial.print(" IPGOFF");}
-  if (prsstat & SDHC_PRSSTAT_SDSTB) {Serial.print(" SDSTB");}
-  if (prsstat & SDHC_PRSSTAT_DLA) {Serial.print(" DLA");}
-  if (prsstat & SDHC_PRSSTAT_CDIHB) {Serial.print(" CDIHB");}
-  if (prsstat & SDHC_PRSSTAT_CIHB) {Serial.print(" CIHB");}
-  Serial.println();
-  Serial.print("PROCTL ");
-  Serial.print(proctl, HEX);
-  if (proctl & SDHC_PROCTL_SABGREQ) Serial.print(" SABGREQ");
-  Serial.print(" EMODE");
-  Serial.print((proctl >>4) & 3);
-  Serial.print(" DWT");
-  Serial.print((proctl >>1) & 3);
-  Serial.println();
-  Serial.print("IRQSTAT ");
-  Serial.print(irqstat, HEX);
-  if (irqstat & SDHC_IRQSTAT_BGE) {Serial.print(" BGE");}
-  if (irqstat & SDHC_IRQSTAT_TC) {Serial.print(" TC");}
-  if (irqstat & SDHC_IRQSTAT_CC) {Serial.print(" CC");}
-  Serial.print("\nm_irqstat ");
-  Serial.println(m_irqstat, HEX);
-}
-#else  // USE_DEBUG_MODE
-#define DBG_IRQSTAT()
-#endif  // USE_DEBUG_MODE
-//==============================================================================
-// Error function and macro.
-#define sdError(code) setSdErrorCode(code, __LINE__)
-inline bool setSdErrorCode(uint8_t code, uint32_t line) {
-  m_errorCode = code;
-  m_errorLine = line;
-#if USE_DEBUG_MODE
-  printRegs(line);
-#endif  // USE_DEBUG_MODE
-  return false;
-}
-//==============================================================================
-// ISR
-static void sdIrs() {
-  SDHC_IRQSIGEN = 0;
-  m_irqstat = SDHC_IRQSTAT;
-  SDHC_IRQSTAT = m_irqstat;
-#if defined(__IMXRT1062__)
-  SDHC_MIX_CTRL &= ~(SDHC_MIX_CTRL_AC23EN | SDHC_MIX_CTRL_DMAEN);
-#endif
-  m_dmaBusy = false;
-}
-//==============================================================================
-// GPIO and clock functions.
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-//------------------------------------------------------------------------------
-static void enableGPIO(bool enable) {
-  const uint32_t PORT_CLK = PORT_PCR_MUX(4) | PORT_PCR_DSE;
-  const uint32_t PORT_CMD_DATA = PORT_CLK   | PORT_PCR_PE | PORT_PCR_PS;
-  const uint32_t PORT_PUP = PORT_PCR_MUX(1) | PORT_PCR_PE | PORT_PCR_PS;
-
-  PORTE_PCR0 = enable ? PORT_CMD_DATA : PORT_PUP;  // SDHC_D1
-  PORTE_PCR1 = enable ? PORT_CMD_DATA : PORT_PUP;  // SDHC_D0
-  PORTE_PCR2 = enable ? PORT_CLK      : PORT_PUP;  // SDHC_CLK
-  PORTE_PCR3 = enable ? PORT_CMD_DATA : PORT_PUP;  // SDHC_CMD
-  PORTE_PCR4 = enable ? PORT_CMD_DATA : PORT_PUP;  // SDHC_D3
-  PORTE_PCR5 = enable ? PORT_CMD_DATA : PORT_PUP;  // SDHC_D2
-}
-//------------------------------------------------------------------------------
-static void initClock() {
-#ifdef HAS_KINETIS_MPU
-  // Allow SDHC Bus Master access.
-  MPU_RGDAAC0 |= 0x0C000000;
-#endif  // HAS_KINETIS_MPU
-  // Enable SDHC clock.
-  SIM_SCGC3 |= SIM_SCGC3_SDHC;
-}
-static uint32_t baseClock() { return F_CPU;}
-
-#elif defined(__IMXRT1062__)
-//------------------------------------------------------------------------------
-static void gpioMux(uint8_t mode) {
-  IOMUXC_SW_MUX_CTL_PAD_GPIO_SD_B0_04 = mode;  // DAT2
-  IOMUXC_SW_MUX_CTL_PAD_GPIO_SD_B0_05 = mode;  // DAT3
-  IOMUXC_SW_MUX_CTL_PAD_GPIO_SD_B0_00 = mode;  // CMD
-  IOMUXC_SW_MUX_CTL_PAD_GPIO_SD_B0_01 = mode;  // CLK
-  IOMUXC_SW_MUX_CTL_PAD_GPIO_SD_B0_02 = mode;  // DAT0
-  IOMUXC_SW_MUX_CTL_PAD_GPIO_SD_B0_03 = mode;  // DAT1
-}
-//------------------------------------------------------------------------------
-// add speed strength args?
-static void enableGPIO(bool enable) {
-  const uint32_t CLOCK_MASK = IOMUXC_SW_PAD_CTL_PAD_PKE |
-#if defined(ARDUINO_TEENSY41)
-                              IOMUXC_SW_PAD_CTL_PAD_DSE(7) |
-#else  // defined(ARDUINO_TEENSY41)
-                              IOMUXC_SW_PAD_CTL_PAD_DSE(4) |  ///// WHG
-#endif  // defined(ARDUINO_TEENSY41)
-                              IOMUXC_SW_PAD_CTL_PAD_SPEED(2);
-
-  const uint32_t DATA_MASK = CLOCK_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE |
-                             IOMUXC_SW_PAD_CTL_PAD_PUS(1);
-  if (enable) {
-    gpioMux(0);
-    IOMUXC_SW_PAD_CTL_PAD_GPIO_SD_B0_04 = DATA_MASK;   // DAT2
-    IOMUXC_SW_PAD_CTL_PAD_GPIO_SD_B0_05 = DATA_MASK;   // DAT3
-    IOMUXC_SW_PAD_CTL_PAD_GPIO_SD_B0_00 = DATA_MASK;   // CMD
-    IOMUXC_SW_PAD_CTL_PAD_GPIO_SD_B0_01 = CLOCK_MASK;  // CLK
-    IOMUXC_SW_PAD_CTL_PAD_GPIO_SD_B0_02 = DATA_MASK;   // DAT0
-    IOMUXC_SW_PAD_CTL_PAD_GPIO_SD_B0_03 = DATA_MASK;   // DAT1
-  } else {
-    gpioMux(5);
-  }
-}
-//------------------------------------------------------------------------------
-static void initClock() {
-  /* set PDF_528 PLL2PFD0 */
-  CCM_ANALOG_PFD_528 |= (1 << 7);
-  CCM_ANALOG_PFD_528 &= ~(0x3F << 0);
-  CCM_ANALOG_PFD_528 |= ((24) & 0x3F << 0);  // 12 - 35
-  CCM_ANALOG_PFD_528 &= ~(1 << 7);
-
-  /* Enable USDHC clock. */
-  CCM_CCGR6 |= CCM_CCGR6_USDHC1(CCM_CCGR_ON);
-  CCM_CSCDR1 &= ~(CCM_CSCDR1_USDHC1_CLK_PODF_MASK);
-  CCM_CSCMR1 |= CCM_CSCMR1_USDHC1_CLK_SEL;          // PLL2PFD0
-//  CCM_CSCDR1 |= CCM_CSCDR1_USDHC1_CLK_PODF((7)); / &0x7  WHG
-  CCM_CSCDR1 |= CCM_CSCDR1_USDHC1_CLK_PODF((1));
-}
-//------------------------------------------------------------------------------
-static uint32_t baseClock() {
-  uint32_t divider = ((CCM_CSCDR1 >> 11) & 0x7) + 1;
-  return (528000000U * 3)/((CCM_ANALOG_PFD_528 & 0x3F)/6)/divider;
-}
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-//==============================================================================
-// Static functions.
-static bool cardAcmd(uint32_t rca, uint32_t xfertyp, uint32_t arg) {
-  return cardCommand(CMD55_XFERTYP, rca) && cardCommand (xfertyp, arg);
-}
-//------------------------------------------------------------------------------
-static bool cardCommand(uint32_t xfertyp, uint32_t arg) {
-  DBG_IRQSTAT();
-  if (waitTimeout(isBusyCommandInhibit)) {
-    return false;  // Caller will set errorCode.
-  }
-  SDHC_CMDARG = arg;
-#if defined(__IMXRT1062__)
-  // Set MIX_CTRL if data transfer.
-  if (xfertyp & SDHC_XFERTYP_DPSEL) {
-    SDHC_MIX_CTRL &= ~SDHC_MIX_CTRL_MASK;
-    SDHC_MIX_CTRL |= xfertyp & SDHC_MIX_CTRL_MASK;
-  }
-  xfertyp &= ~SDHC_MIX_CTRL_MASK;
-#endif  // defined(__IMXRT1062__)
-  SDHC_XFERTYP = xfertyp;
-  if (waitTimeout(isBusyCommandComplete)) {
-    return false;  // Caller will set errorCode.
-  }
-  m_irqstat = SDHC_IRQSTAT;
-  SDHC_IRQSTAT = m_irqstat;
-
-  return (m_irqstat & SDHC_IRQSTAT_CC) &&
-         !(m_irqstat & SDHC_IRQSTAT_CMD_ERROR);
-}
-//------------------------------------------------------------------------------
-static bool cardACMD51(scr_t* scr) {
-  // ACMD51 returns 8 bytes.
-  if (waitTimeout(isBusyCMD13)) {
-    return sdError(SD_CARD_ERROR_CMD13);
-  }
-  enableDmaIrs();
-  SDHC_DSADDR  = (uint32_t)scr;
-  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(1) | SDHC_BLKATTR_BLKSIZE(8);
-  SDHC_IRQSIGEN = SDHC_IRQSIGEN_MASK;
-  if (!cardAcmd(m_rca, ACMD51_XFERTYP, 0)) {
-    return sdError(SD_CARD_ERROR_ACMD51);
-  }
-  if (!waitDmaStatus()) {
-    return sdError(SD_CARD_ERROR_DMA);
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-static void enableDmaIrs() {
-  m_dmaBusy = true;
-  m_irqstat = 0;
-}
-//------------------------------------------------------------------------------
-static void initSDHC() {
-  initClock();
-
-  // Disable GPIO clock.
-  enableGPIO(false);
-
-#if defined (__IMXRT1062__)
-  SDHC_MIX_CTRL |= 0x80000000;
-#endif  //  (__IMXRT1062__)
-
-  // Reset SDHC. Use default Water Mark Level of 16.
-  SDHC_SYSCTL |= SDHC_SYSCTL_RSTA | SDHC_SYSCTL_SDCLKFS(0x80);
-
-  while (SDHC_SYSCTL & SDHC_SYSCTL_RSTA) {
-  }
-
-  // Set initial SCK rate.
-  setSdclk(SD_MAX_INIT_RATE_KHZ);
-
-  enableGPIO(true);
-
-  // Enable desired IRQSTAT bits.
-  SDHC_IRQSTATEN = SDHC_IRQSTATEN_MASK;
-
-  attachInterruptVector(IRQ_SDHC, sdIrs);
-  NVIC_SET_PRIORITY(IRQ_SDHC, 6*16);
-  NVIC_ENABLE_IRQ(IRQ_SDHC);
-
-  // Send 80 clocks to card.
-  SDHC_SYSCTL |= SDHC_SYSCTL_INITA;
-  while (SDHC_SYSCTL & SDHC_SYSCTL_INITA) {
-  }
-}
-//------------------------------------------------------------------------------
-static uint32_t statusCMD13() {
-  return cardCommand(CMD13_XFERTYP, m_rca) ? SDHC_CMDRSP0 : 0;
-}
-//------------------------------------------------------------------------------
-static bool isBusyCMD13() {
-  return !(statusCMD13() & CARD_STATUS_READY_FOR_DATA);
-}
-//------------------------------------------------------------------------------
-static bool isBusyCommandComplete() {
-  return !(SDHC_IRQSTAT & (SDHC_IRQSTAT_CC | SDHC_IRQSTAT_CMD_ERROR));
-}
-//------------------------------------------------------------------------------
-static bool isBusyCommandInhibit() {
-  return SDHC_PRSSTAT & SDHC_PRSSTAT_CIHB;
-}
-//------------------------------------------------------------------------------
-static bool isBusyDat() {
-  return SDHC_PRSSTAT & (1 << 24) ? false : true;
-}
-//------------------------------------------------------------------------------
-static bool isBusyDMA() {
-  return m_dmaBusy;
-}
-//------------------------------------------------------------------------------
-static bool isBusyFifoRead() {
-  return !(SDHC_PRSSTAT & SDHC_PRSSTAT_BREN);
-}
-//------------------------------------------------------------------------------
-static bool isBusyFifoWrite() {
-  return !(SDHC_PRSSTAT & SDHC_PRSSTAT_BWEN);
-}
-//------------------------------------------------------------------------------
-static bool isBusyTransferComplete() {
-  return !(SDHC_IRQSTAT & (SDHC_IRQSTAT_TC | SDHC_IRQSTAT_ERROR));
-}
-//------------------------------------------------------------------------------
-static bool rdWrSectors(uint32_t xfertyp,
-                       uint32_t sector, uint8_t* buf, size_t n) {
-  if ((3 & (uint32_t)buf) || n == 0) {
-    return sdError(SD_CARD_ERROR_DMA);
-  }
-  if (yieldTimeout(isBusyCMD13)) {
-    return sdError(SD_CARD_ERROR_CMD13);
-  }
-  enableDmaIrs();
-  SDHC_DSADDR  = (uint32_t)buf;
-  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(n) | SDHC_BLKATTR_BLKSIZE(512);
-  SDHC_IRQSIGEN = SDHC_IRQSIGEN_MASK;
-  if (!cardCommand(xfertyp, m_highCapacity ? sector : 512*sector)) {
-    return false;
-  }
-  return waitDmaStatus();
-}
-//------------------------------------------------------------------------------
-// Read 16 byte CID or CSD register.
-static bool readReg16(uint32_t xfertyp, void* data) {
-  uint8_t* d = reinterpret_cast<uint8_t*>(data);
-  if (!cardCommand(xfertyp, m_rca)) {
-    return false;  // Caller will set errorCode.
-  }
-  uint32_t sr[] = {SDHC_CMDRSP0, SDHC_CMDRSP1, SDHC_CMDRSP2, SDHC_CMDRSP3};
-  for (int i = 0; i < 15; i++) {
-    d[14 - i] = sr[i/4] >> 8*(i%4);
-  }
-  d[15] = 0;
-  return true;
-}
-//------------------------------------------------------------------------------
-static void setSdclk(uint32_t kHzMax) {
-  const uint32_t DVS_LIMIT = 0X10;
-  const uint32_t SDCLKFS_LIMIT = 0X100;
-  uint32_t dvs = 1;
-  uint32_t sdclkfs = 1;
-  uint32_t maxSdclk = 1000*kHzMax;
-  uint32_t base = baseClock();
-
-  while ((base/(sdclkfs*DVS_LIMIT) > maxSdclk) && (sdclkfs < SDCLKFS_LIMIT)) {
-    sdclkfs <<= 1;
-  }
-  while ((base/(sdclkfs*dvs) > maxSdclk) && (dvs < DVS_LIMIT)) {
-    dvs++;
-  }
-  m_sdClkKhz = base/(1000*sdclkfs*dvs);
-  sdclkfs >>= 1;
-  dvs--;
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-  // Disable SDHC clock.
-  SDHC_SYSCTL &= ~SDHC_SYSCTL_SDCLKEN;
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-
-  // Change dividers.
-  uint32_t sysctl = SDHC_SYSCTL & ~(SDHC_SYSCTL_DTOCV_MASK
-                    | SDHC_SYSCTL_DVS_MASK | SDHC_SYSCTL_SDCLKFS_MASK);
-
-  SDHC_SYSCTL = sysctl | SDHC_SYSCTL_DTOCV(0x0E) | SDHC_SYSCTL_DVS(dvs)
-                | SDHC_SYSCTL_SDCLKFS(sdclkfs);
-
-  // Wait until the SDHC clock is stable.
-  while (!(SDHC_PRSSTAT & SDHC_PRSSTAT_SDSTB)) {
-  }
-
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-  // Enable the SDHC clock.
-  SDHC_SYSCTL |= SDHC_SYSCTL_SDCLKEN;
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-}
-//------------------------------------------------------------------------------
-static bool transferStop() {
-  // This fix allows CDIHB to be cleared in Tennsy 3.x without a reset.
-  SDHC_PROCTL &= ~SDHC_PROCTL_SABGREQ;
-  if (!cardCommand(CMD12_XFERTYP, 0)) {
-    return sdError(SD_CARD_ERROR_CMD12);
-  }
-  if (yieldTimeout(isBusyDat)) {
-    return sdError(SD_CARD_ERROR_CMD13);
-  }
-  if (SDHC_PRSSTAT & SDHC_PRSSTAT_CDIHB) {
-    // This should not happen after above fix.
-    // Save registers before reset DAT lines.
-    uint32_t irqsststen = SDHC_IRQSTATEN;
-    uint32_t proctl = SDHC_PROCTL & ~SDHC_PROCTL_SABGREQ;
-    // Do reset to clear CDIHB.  Should be a better way!
-    SDHC_SYSCTL |= SDHC_SYSCTL_RSTD;
-    // Restore registers.
-    SDHC_IRQSTATEN = irqsststen;
-    SDHC_PROCTL = proctl;
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-// Return true if timeout occurs.
-static bool yieldTimeout(bool (*fcn)()) {
-  m_busyFcn = fcn;
-  uint32_t m = micros();
-  while (fcn()) {
-    if ((micros() - m) > BUSY_TIMEOUT_MICROS) {
-      m_busyFcn = 0;
-      return true;
-    }
-    yield();
-  }
-  m_busyFcn = 0;
-  return false;  // Caller will set errorCode.
-}
-//------------------------------------------------------------------------------
-static bool waitDmaStatus() {
-  if (yieldTimeout(isBusyDMA)) {
-    return false;  // Caller will set errorCode.
-  }
-  return (m_irqstat & SDHC_IRQSTAT_TC) && !(m_irqstat & SDHC_IRQSTAT_ERROR);
-}
-//------------------------------------------------------------------------------
-// Return true if timeout occurs.
-static bool waitTimeout(bool (*fcn)()) {
-  uint32_t m = micros();
-  while (fcn()) {
-    if ((micros() - m) > BUSY_TIMEOUT_MICROS) {
-      return true;
-    }
-  }
-  return false;  // Caller will set errorCode.
-}
-//------------------------------------------------------------------------------
-static bool waitTransferComplete() {
-  if (!m_transferActive) {
-    return true;
-  }
-  bool timeOut = waitTimeout(isBusyTransferComplete);
-  m_transferActive = false;
-  m_irqstat = SDHC_IRQSTAT;
-  SDHC_IRQSTAT = m_irqstat;
-  if (timeOut || (m_irqstat & SDHC_IRQSTAT_ERROR)) {
-    return sdError(SD_CARD_ERROR_TRANSFER_COMPLETE);
-  }
-  return true;
-}
-//==============================================================================
-// Start of SdioCard member functions.
-//==============================================================================
-bool SdioCard::begin(SdioConfig sdioConfig) {
-  uint32_t kHzSdClk;
-  uint32_t arg;
-  m_sdioConfig = sdioConfig;
-  m_curState = IDLE_STATE;
-  m_initDone = false;
-  m_errorCode = SD_CARD_ERROR_NONE;
-  m_highCapacity = false;
-  m_version2 = false;
-
-  // initialize controller.
-  initSDHC();
-  if (!cardCommand(CMD0_XFERTYP, 0)) {
-    return sdError(SD_CARD_ERROR_CMD0);
-  }
-  // Try several times for case of reset delay.
-  for (uint32_t i = 0; i < CMD8_RETRIES; i++) {
-    if (cardCommand(CMD8_XFERTYP, 0X1AA)) {
-      if (SDHC_CMDRSP0 != 0X1AA) {
-        return sdError(SD_CARD_ERROR_CMD8);
-      }
-      m_version2 = true;
-      break;
-    }
-    SDHC_SYSCTL |= SDHC_SYSCTL_RSTA;
-    while (SDHC_SYSCTL & SDHC_SYSCTL_RSTA) {}
-  }
-  // Must support 3.2-3.4 Volts
-  arg = m_version2 ? 0X40300000 : 0x00300000;
-  int m = micros();
-  do {
-    if (!cardAcmd(0, ACMD41_XFERTYP, arg) ||
-       ((micros() - m) > BUSY_TIMEOUT_MICROS)) {
-      return sdError(SD_CARD_ERROR_ACMD41);
-    }
-  } while ((SDHC_CMDRSP0 & 0x80000000) == 0);
-  m_ocr = SDHC_CMDRSP0;
-  if (SDHC_CMDRSP0 & 0x40000000) {
-    // Is high capacity.
-    m_highCapacity = true;
-  }
-  if (!cardCommand(CMD2_XFERTYP, 0)) {
-    return sdError(SD_CARD_ERROR_CMD2);
-  }
-  if (!cardCommand(CMD3_XFERTYP, 0)) {
-    return sdError(SD_CARD_ERROR_CMD3);
-  }
-  m_rca = SDHC_CMDRSP0 & 0xFFFF0000;
-
-  if (!readReg16(CMD9_XFERTYP, &m_csd)) {
-    return sdError(SD_CARD_ERROR_CMD9);
-  }
-  if (!readReg16(CMD10_XFERTYP, &m_cid)) {
-    return sdError(SD_CARD_ERROR_CMD10);
-  }
-  if (!cardCommand(CMD7_XFERTYP, m_rca)) {
-    return sdError(SD_CARD_ERROR_CMD7);
-  }
-  // Set card to bus width four.
-  if (!cardAcmd(m_rca, ACMD6_XFERTYP, 2)) {
-    return sdError(SD_CARD_ERROR_ACMD6);
-  }
-  // Set SDHC to bus width four.
-  SDHC_PROCTL &= ~SDHC_PROCTL_DTW_MASK;
-  SDHC_PROCTL |= SDHC_PROCTL_DTW(SDHC_PROCTL_DTW_4BIT);
-
-  SDHC_WML = SDHC_WML_RDWML(FIFO_WML) | SDHC_WML_WRWML(FIFO_WML);
-
-  if (!cardACMD51(&m_scr)) {
-    return false;
-  }
-  // Determine if High Speed mode is supported and set frequency.
-  // Check status[16] for error 0XF or status[16] for new mode 0X1.
-  uint8_t status[64];
-  if (m_scr.sdSpec() > 0 &&
-      cardCMD6(0X00FFFFFF, status) && (2 & status[13]) &&
-      cardCMD6(0X80FFFFF1, status) && (status[16] & 0XF) == 1) {
-    kHzSdClk = 50000;
-  } else {
-    kHzSdClk = 25000;
-  }
-  // Disable GPIO.
-  enableGPIO(false);
-
-  // Set the SDHC SCK frequency.
-  setSdclk(kHzSdClk);
-
-  // Enable GPIO.
-  enableGPIO(true);
-  m_initDone = true;
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::cardCMD6(uint32_t arg, uint8_t* status) {
-  // CMD6 returns 64 bytes.
-  if (waitTimeout(isBusyCMD13)) {
-    return sdError(SD_CARD_ERROR_CMD13);
-  }
-  enableDmaIrs();
-  SDHC_DSADDR  = (uint32_t)status;
-  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(1) | SDHC_BLKATTR_BLKSIZE(64);
-  SDHC_IRQSIGEN = SDHC_IRQSIGEN_MASK;
-  if (!cardCommand(CMD6_XFERTYP, arg)) {
-    return sdError(SD_CARD_ERROR_CMD6);
-  }
-  if (!waitDmaStatus()) {
-    return sdError(SD_CARD_ERROR_DMA);
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::erase(uint32_t firstSector, uint32_t lastSector) {
-  if (m_curState != IDLE_STATE && !syncDevice()) {
-    return false;
-  }
-  // check for single sector erase
-  if (!m_csd.eraseSingleBlock()) {
-    // erase size mask
-    uint8_t m = m_csd.eraseSize() - 1;
-    if ((firstSector & m) != 0 || ((lastSector + 1) & m) != 0) {
-      // error card can't erase specified area
-      return sdError(SD_CARD_ERROR_ERASE_SINGLE_SECTOR);
-    }
-  }
-  if (!m_highCapacity) {
-    firstSector <<= 9;
-    lastSector <<= 9;
-  }
-  if (!cardCommand(CMD32_XFERTYP, firstSector)) {
-    return sdError(SD_CARD_ERROR_CMD32);
-  }
-  if (!cardCommand(CMD33_XFERTYP, lastSector)) {
-     return sdError(SD_CARD_ERROR_CMD33);
-  }
-  if (!cardCommand(CMD38_XFERTYP, 0)) {
-    return sdError(SD_CARD_ERROR_CMD38);
-  }
-  if (waitTimeout(isBusyCMD13)) {
-    return sdError(SD_CARD_ERROR_ERASE_TIMEOUT);
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-uint8_t SdioCard::errorCode() const {
-  return m_errorCode;
-}
-//------------------------------------------------------------------------------
-uint32_t SdioCard::errorData() const {
-  return m_irqstat;
-}
-//------------------------------------------------------------------------------
-uint32_t SdioCard::errorLine() const {
-  return m_errorLine;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::isBusy() {
-  if (m_sdioConfig.useDma()) {
-    return m_busyFcn ? m_busyFcn() : m_initDone && isBusyCMD13();
-  } else {
-    if (m_transferActive) {
-      if (isBusyTransferComplete()) {
-        return true;
-      }
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-      if ((SDHC_BLKATTR & 0XFFFF0000) != 0) {
-        return false;
-      }
-      m_transferActive = false;
-      stopTransmission(false);
-      return true;
-#else  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-      return false;
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-    }
-    // Use DAT0 low as busy.
-    return SDHC_PRSSTAT & (1 << 24) ? false : true;
-  }
-}
-//------------------------------------------------------------------------------
-uint32_t SdioCard::kHzSdClk() {
-  return m_sdClkKhz;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::readCID(cid_t* cid) {
-  memcpy(cid, &m_cid, 16);
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::readCSD(csd_t* csd) {
-  memcpy(csd, &m_csd, 16);
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::readData(uint8_t* dst) {
-  DBG_IRQSTAT();
-  uint32_t* p32 = reinterpret_cast<uint32_t*>(dst);
-
-  if (!(SDHC_PRSSTAT & SDHC_PRSSTAT_RTA)) {
-    SDHC_PROCTL &= ~SDHC_PROCTL_SABGREQ;
-    noInterrupts();
-    SDHC_PROCTL |= SDHC_PROCTL_CREQ;
-    SDHC_PROCTL |= SDHC_PROCTL_SABGREQ;
-    interrupts();
-  }
-  if (waitTimeout(isBusyFifoRead)) {
-    return sdError(SD_CARD_ERROR_READ_FIFO);
-  }
-  for (uint32_t iw = 0 ; iw < 512/(4*FIFO_WML); iw++) {
-    while (0 == (SDHC_PRSSTAT & SDHC_PRSSTAT_BREN)) {
-    }
-    for (uint32_t i = 0; i < FIFO_WML; i++) {
-      p32[i] = SDHC_DATPORT;
-    }
-    p32 += FIFO_WML;
-  }
-  if (waitTimeout(isBusyTransferComplete)) {
-    return sdError(SD_CARD_ERROR_READ_TIMEOUT);
-  }
-  m_irqstat = SDHC_IRQSTAT;
-  SDHC_IRQSTAT = m_irqstat;
-  return (m_irqstat & SDHC_IRQSTAT_TC) && !(m_irqstat & SDHC_IRQSTAT_ERROR);
-}
-//------------------------------------------------------------------------------
-bool SdioCard::readOCR(uint32_t* ocr) {
-  *ocr = m_ocr;
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::readSCR(scr_t* scr) {
-  memcpy(scr, &m_scr, 8);
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::readSector(uint32_t sector, uint8_t* dst) {
-  if (m_sdioConfig.useDma()) {
-    uint8_t aligned[512];
-
-    uint8_t* ptr = (uint32_t)dst & 3 ? aligned : dst;
-
-    if (!rdWrSectors(CMD17_DMA_XFERTYP, sector, ptr, 1)) {
-      return sdError(SD_CARD_ERROR_CMD17);
-    }
-    if (ptr != dst) {
-      memcpy(dst, aligned, 512);
-    }
-  } else {
-    if (!waitTransferComplete()) {
-      return false;
-    }
-    if (m_curState != READ_STATE || sector != m_curSector) {
-      if (!syncDevice()) {
-        return false;
-      }
-      if (!readStart(sector)) {
-        return false;
-      }
-      m_curSector = sector;
-      m_curState = READ_STATE;
-    }
-    if (!readData(dst)) {
-      return false;
-    }
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-    if ((SDHC_BLKATTR & 0XFFFF0000) == 0) {
-      if (!syncDevice()) {
-        return false;
-      }
-    }
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-    m_curSector++;
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::readSectors(uint32_t sector, uint8_t* dst, size_t n) {
-  if (m_sdioConfig.useDma()) {
-    if ((uint32_t)dst & 3) {
-      for (size_t i = 0; i < n; i++, sector++, dst += 512) {
-        if (!readSector(sector, dst)) {
-          return false;  // readSector will set errorCode.
-        }
-      }
-      return true;
-    }
-    if (!rdWrSectors(CMD18_DMA_XFERTYP, sector, dst, n)) {
-      return sdError(SD_CARD_ERROR_CMD18);
-    }
-  } else {
-    for (size_t i = 0; i < n; i++) {
-      if (!readSector(sector + i, dst + i*512UL)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-// SDHC will do Auto CMD12 after count sectors.
-bool SdioCard::readStart(uint32_t sector) {
-  DBG_IRQSTAT();
-  if (yieldTimeout(isBusyCMD13)) {
-    return sdError(SD_CARD_ERROR_CMD13);
-  }
-  SDHC_PROCTL |= SDHC_PROCTL_SABGREQ;
-#if defined(__IMXRT1062__)
-  // Infinite transfer.
-  SDHC_BLKATTR = SDHC_BLKATTR_BLKSIZE(512);
-#else  // defined(__IMXRT1062__)
-  // Errata - can't do infinite transfer.
-  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(MAX_BLKCNT) | SDHC_BLKATTR_BLKSIZE(512);
-#endif  // defined(__IMXRT1062__)
-
-  if (!cardCommand(CMD18_PGM_XFERTYP, m_highCapacity ? sector : 512*sector)) {
-    return sdError(SD_CARD_ERROR_CMD18);
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::readStop() {
-  return transferStop();
-}
-//------------------------------------------------------------------------------
-uint32_t SdioCard::sectorCount() {
-  return m_csd.capacity();
-}
-//------------------------------------------------------------------------------
-uint32_t SdioCard::status() {
-  return statusCMD13();
-}
-//------------------------------------------------------------------------------
-bool SdioCard::stopTransmission(bool blocking) {
-  m_curState = IDLE_STATE;
-  // This fix allows CDIHB to be cleared in Tennsy 3.x without a reset.
-  SDHC_PROCTL &= ~SDHC_PROCTL_SABGREQ;
-  if (!cardCommand(CMD12_XFERTYP, 0)) {
-    return sdError(SD_CARD_ERROR_CMD12);
-  }
-  if (blocking) {
-    if (yieldTimeout(isBusyDat)) {
-      return sdError(SD_CARD_ERROR_CMD13);
-    }
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::syncDevice() {
-  if (!waitTransferComplete()) {
-    return false;
-  }
-  if (m_curState != IDLE_STATE) {
-    return stopTransmission(true);
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-uint8_t SdioCard::type() const {
-  return  m_version2 ? m_highCapacity ?
-          SD_CARD_TYPE_SDHC : SD_CARD_TYPE_SD2 : SD_CARD_TYPE_SD1;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::writeData(const uint8_t* src) {
-  DBG_IRQSTAT();
-  if (!waitTransferComplete()) {
-    return false;
-  }
-  const uint32_t* p32 = reinterpret_cast<const uint32_t*>(src);
-  if (!(SDHC_PRSSTAT & SDHC_PRSSTAT_WTA)) {
-    SDHC_PROCTL &= ~SDHC_PROCTL_SABGREQ;
-    SDHC_PROCTL |= SDHC_PROCTL_CREQ;
-  }
-  SDHC_PROCTL |= SDHC_PROCTL_SABGREQ;
-  if (waitTimeout(isBusyFifoWrite)) {
-    return sdError(SD_CARD_ERROR_WRITE_FIFO);
-  }
-  for (uint32_t iw = 0 ; iw < 512/(4*FIFO_WML); iw++) {
-    while (0 == (SDHC_PRSSTAT & SDHC_PRSSTAT_BWEN)) {
-    }
-    for (uint32_t i = 0; i < FIFO_WML; i++) {
-      SDHC_DATPORT = p32[i];
-    }
-    p32 += FIFO_WML;
-  }
-  m_transferActive = true;
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::writeSector(uint32_t sector, const uint8_t* src) {
-  if (m_sdioConfig.useDma()) {
-    uint8_t* ptr;
-    uint8_t aligned[512];
-    if (3 & (uint32_t)src) {
-      ptr = aligned;
-      memcpy(aligned, src, 512);
-    } else {
-      ptr = const_cast<uint8_t*>(src);
-    }
-    if (!rdWrSectors(CMD24_DMA_XFERTYP, sector, ptr, 1)) {
-      return sdError(SD_CARD_ERROR_CMD24);
-    }
-  } else {
-    if (!waitTransferComplete()) {
-      return false;
-    }
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-    // End transfer with CMD12 if required.
-    if ((SDHC_BLKATTR & 0XFFFF0000) == 0) {
-      if (!syncDevice()) {
-        return false;
-      }
-    }
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-    if (m_curState != WRITE_STATE || m_curSector != sector) {
-      if (!syncDevice()) {
-        return false;
-      }
-      if (!writeStart(sector )) {
-        return false;
-      }
-      m_curSector = sector;
-      m_curState = WRITE_STATE;
-    }
-    if (!writeData(src)) {
-      return false;
-    }
-    m_curSector++;
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::writeSectors(uint32_t sector, const uint8_t* src, size_t n) {
-  if (m_sdioConfig.useDma()) {
-    uint8_t* ptr = const_cast<uint8_t*>(src);
-    if (3 & (uint32_t)ptr) {
-      for (size_t i = 0; i < n; i++, sector++, ptr += 512) {
-        if (!writeSector(sector, ptr)) {
-          return false;  // writeSector will set errorCode.
-        }
-      }
-      return true;
-    }
-    if (!rdWrSectors(CMD25_DMA_XFERTYP, sector, ptr, n)) {
-      return sdError(SD_CARD_ERROR_CMD25);
-    }
-  } else {
-    for (size_t i = 0; i < n; i++) {
-      if (!writeSector(sector + i, src + i*512UL)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::writeStart(uint32_t sector) {
-  if (yieldTimeout(isBusyCMD13)) {
-    return sdError(SD_CARD_ERROR_CMD13);
-  }
-  SDHC_PROCTL &= ~SDHC_PROCTL_SABGREQ;
-
-#if defined(__IMXRT1062__)
-  // Infinite transfer.
-  SDHC_BLKATTR = SDHC_BLKATTR_BLKSIZE(512);
-#else  // defined(__IMXRT1062__)
-  // Errata - can't do infinite transfer.
-  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(MAX_BLKCNT) | SDHC_BLKATTR_BLKSIZE(512);
-#endif  // defined(__IMXRT1062__)
-  if (!cardCommand(CMD25_PGM_XFERTYP, m_highCapacity ? sector : 512*sector)) {
-    return sdError(SD_CARD_ERROR_CMD25);
-  }
-  return true;
-}
-//------------------------------------------------------------------------------
-bool SdioCard::writeStop() {
-  return transferStop();
-}
-#endif  // defined(__MK64FX512__)  defined(__MK66FX1M0__) defined(__IMXRT1062__)

lib/SdFat_NoArduino/src/SdFat.h

@@ -1,514 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef SdFat_h
-#define SdFat_h
-/**
- * \file
- * \brief main SdFs include file.
- */
-#include "common/SysCall.h"
-#include "SdCard/SdCard.h"
-#include "ExFatLib/ExFatLib.h"
-#include "FatLib/FatLib.h"
-#include "FsLib/FsLib.h"
-#if INCLUDE_SDIOS
-#include "sdios.h"
-#endif  // INCLUDE_SDIOS
-//------------------------------------------------------------------------------
-/** SdFat version for cpp use. */
-#define SD_FAT_VERSION 20200
-/** SdFat version as string. */
-#define SD_FAT_VERSION_STR "2.2.0"
-//==============================================================================
-/**
- * \class SdBase
- * \brief base SD file system template class.
- */
-template <class Vol, class Fmt>
-class SdBase : public Vol {
- public:
-  //----------------------------------------------------------------------------
-  /** Initialize SD card and file system.
-   *
-   * \param[in] csPin SD card chip select pin.
-   * \return true for success or false for failure.
-   */
-  bool begin(SdCsPin_t csPin = SS) {
-#ifdef BUILTIN_SDCARD
-    if (csPin == BUILTIN_SDCARD) {
-      return begin(SdioConfig(FIFO_SDIO));
-    }
-#endif  // BUILTIN_SDCARD
-    return begin(SdSpiConfig(csPin, SHARED_SPI));
-  }
-  //----------------------------------------------------------------------------
-  /** Initialize SD card and file system.
-   *
-   * \param[in] csPin SD card chip select pin.
-   * \param[in] maxSck Maximum SCK frequency.
-   * \return true for success or false for failure.
-   */
-  bool begin(SdCsPin_t csPin, uint32_t maxSck) {
-    return begin(SdSpiConfig(csPin, SHARED_SPI, maxSck));
-  }
-  //----------------------------------------------------------------------------
-  /** Initialize SD card and file system for SPI mode.
-   *
-   * \param[in] spiConfig SPI configuration.
-   * \return true for success or false for failure.
-   */
-  bool begin(SdSpiConfig spiConfig) {
-    return cardBegin(spiConfig) && Vol::begin(m_card);
-  }
-  //---------------------------------------------------------------------------
-  /** Initialize SD card and file system for SDIO mode.
-   *
-   * \param[in] sdioConfig SDIO configuration.
-   * \return true for success or false for failure.
-   */
-  bool begin(SdioConfig sdioConfig) {
-    return cardBegin(sdioConfig) && Vol::begin(m_card);
-  }
-  //----------------------------------------------------------------------------
-  /** \return Pointer to SD card object. */
-  SdCard* card() {return m_card;}
-  //----------------------------------------------------------------------------
-  /** Initialize SD card in SPI mode.
-   *
-   * \param[in] spiConfig SPI configuration.
-   * \return true for success or false for failure.
-   */
-  bool cardBegin(SdSpiConfig spiConfig) {
-    m_card = m_cardFactory.newCard(spiConfig);
-    return m_card && !m_card->errorCode();
-  }
-  //----------------------------------------------------------------------------
-  /** Initialize SD card in SDIO mode.
-   *
-   * \param[in] sdioConfig SDIO configuration.
-   * \return true for success or false for failure.
-   */
-  bool cardBegin(SdioConfig sdioConfig) {
-    m_card = m_cardFactory.newCard(sdioConfig);
-    return m_card && !m_card->errorCode();
-  }
-  //----------------------------------------------------------------------------
-  /** End use of card. */
-  void end() {
-    Vol::end();
-    if (m_card) {
-      m_card->end();
-    }
-  }
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt.
-   *
-   * \param[in] pr Print destination.
-   */
-  void errorHalt(print_t* pr) {
-    if (sdErrorCode()) {
-      pr->print(F("SdError: 0X"));
-      pr->print(sdErrorCode(), HEX);
-      pr->print(F(",0X"));
-      pr->println(sdErrorData(), HEX);
-    } else if (!Vol::fatType()) {
-      pr->println(F("Check SD format."));
-    }
-    while (true) {}
-  }
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt.
-   *
-   * \param[in] pr Print destination.
-   * \param[in] msg Message to print.
-   */
-  void errorHalt(print_t* pr, const char* msg) {
-    pr->print(F("error: "));
-    pr->println(msg);
-    errorHalt(pr);
-  }
-  //----------------------------------------------------------------------------
-  /** %Print msg and halt.
-   *
-   * \param[in] pr Print destination.
-   * \param[in] msg Message to print.
-   */
-  void errorHalt(print_t* pr, const __FlashStringHelper* msg) {
-    pr->print(F("error: "));
-    pr->println(msg);
-    errorHalt(pr);
-  }
-  //----------------------------------------------------------------------------
-  /** Format SD card
-   *
-   * \param[in] pr Print destination.
-   * \return true for success else false.
-   */
-  bool format(print_t* pr = nullptr) {
-    Fmt fmt;
-    uint8_t* mem = Vol::end();
-    if (!mem) {
-      return false;
-    }
-    bool switchSpi = hasDedicatedSpi() && !isDedicatedSpi();
-    if (switchSpi && !setDedicatedSpi(true)) {
-      return false;
-    }
-    bool rtn = fmt.format(card(), mem, pr);
-    if (switchSpi && !setDedicatedSpi(false)) {
-      return false;
-    }
-    return rtn;
-  }
-  //----------------------------------------------------------------------------
-  /** \return the free cluster count. */
-  uint32_t freeClusterCount() {
-    bool switchSpi = hasDedicatedSpi() && !isDedicatedSpi();
-    if (switchSpi && !setDedicatedSpi(true)) {
-      return 0;
-    }
-    uint32_t rtn = Vol::freeClusterCount();
-    if (switchSpi && !setDedicatedSpi(false)) {
-      return 0;
-    }
-    return rtn;
-  }
-  //----------------------------------------------------------------------------
-  /** \return true if can be in dedicated SPI state */
-  bool hasDedicatedSpi() {return m_card ? m_card->hasDedicatedSpi() : false;}
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt.
-   *
-   * \param[in] pr Print destination.
-   */
-  void initErrorHalt(print_t* pr) {
-    initErrorPrint(pr);
-    while (true) {}
-  }
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt.
-   *
-   * \param[in] pr Print destination.
-   * \param[in] msg Message to print.
-   */
-  void initErrorHalt(print_t* pr, const char* msg) {
-    pr->println(msg);
-    initErrorHalt(pr);
-  }
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt.
-   *
-   * \param[in] pr Print destination.
-   * \param[in] msg Message to print.
-   */
-  void initErrorHalt(print_t* pr, const __FlashStringHelper* msg) {
-    pr->println(msg);
-    initErrorHalt(pr);
-  }
-  //----------------------------------------------------------------------------
-  /** Print error details after begin() fails.
-   *
-   * \param[in] pr Print destination.
-   */
-  void initErrorPrint(print_t* pr) {
-    pr->println(F("begin() failed"));
-    if (sdErrorCode()) {
-      pr->println(F("Do not reformat the SD."));
-      if (sdErrorCode() == SD_CARD_ERROR_CMD0) {
-        pr->println(F("No card, wrong chip select pin, or wiring error?"));
-      }
-    }
-    errorPrint(pr);
-  }
-  //----------------------------------------------------------------------------
-  /** \return true if in dedicated SPI state. */
-  bool isDedicatedSpi() {return m_card ? m_card->isDedicatedSpi() : false;}
-  //----------------------------------------------------------------------------
-  /** %Print volume FAT/exFAT type.
-   *
-   * \param[in] pr Print destination.
-   */
-  void printFatType(print_t* pr) {
-    if (Vol::fatType() == FAT_TYPE_EXFAT) {
-      pr->print(F("exFAT"));
-    } else {
-      pr->print(F("FAT"));
-      pr->print(Vol::fatType());
-    }
-  }
-  //----------------------------------------------------------------------------
-  /** %Print SD errorCode and errorData.
-   *
-   * \param[in] pr Print destination.
-   */
-  void errorPrint(print_t* pr) {
-    if (sdErrorCode()) {
-      pr->print(F("SdError: 0X"));
-      pr->print(sdErrorCode(), HEX);
-      pr->print(F(",0X"));
-      pr->println(sdErrorData(), HEX);
-    } else if (!Vol::fatType()) {
-      pr->println(F("Check SD format."));
-    }
-  }
-  //----------------------------------------------------------------------------
-  /** %Print msg, any SD error code.
-   *
-   * \param[in] pr Print destination.
-   * \param[in] msg Message to print.
-   */
-  void errorPrint(print_t* pr, char const* msg) {
-    pr->print(F("error: "));
-    pr->println(msg);
-    errorPrint(pr);
-  }
-
-  /** %Print msg, any SD error code.
-   *
-   * \param[in] pr Print destination.
-   * \param[in] msg Message to print.
-   */
-  void errorPrint(print_t* pr, const __FlashStringHelper* msg) {
-    pr->print(F("error: "));
-    pr->println(msg);
-    errorPrint(pr);
-  }
-  //----------------------------------------------------------------------------
-  /** %Print error info and return.
-   *
-   * \param[in] pr Print destination.
-   */
-  void printSdError(print_t* pr) {
-    if (sdErrorCode()) {
-      if (sdErrorCode() == SD_CARD_ERROR_CMD0) {
-        pr->println(F("No card, wrong chip select pin, or wiring error?"));
-      }
-      pr->print(F("SD error: "));
-      printSdErrorSymbol(pr, sdErrorCode());
-      pr->print(F(" = 0x"));
-      pr->print(sdErrorCode(), HEX);
-      pr->print(F(",0x"));
-      pr->println(sdErrorData(), HEX);
-    } else if (!Vol::fatType()) {
-      pr->println(F("Check SD format."));
-    }
-  }
-  //----------------------------------------------------------------------------
-  /** \return SD card error code. */
-  uint8_t sdErrorCode() {
-    if (m_card) {
-      return m_card->errorCode();
-    }
-    return SD_CARD_ERROR_INVALID_CARD_CONFIG;
-  }
-  //----------------------------------------------------------------------------
-  /** \return SD card error data. */
-  uint8_t sdErrorData() {return m_card ? m_card->errorData() : 0;}
-  //----------------------------------------------------------------------------
-  /** Set SPI sharing state
-   * \param[in] value desired state.
-   * \return true for success else false;
-   */
-  bool setDedicatedSpi(bool value) {
-    if (m_card) {
-      return m_card->setDedicatedSpi(value);
-    }
-    return false;
-  }
-  //----------------------------------------------------------------------------
-  /** \return pointer to base volume */
-  Vol* vol() {return reinterpret_cast<Vol*>(this);}
-  //----------------------------------------------------------------------------
-  /** Initialize file system after call to cardBegin.
-   *
-   * \return true for success or false for failure.
-   */
-  bool volumeBegin() {
-     return Vol::begin(m_card);
-  }
-#if ENABLE_ARDUINO_SERIAL
-  /** Print error details after begin() fails. */
-  void initErrorPrint() {
-    initErrorPrint(&Serial);
-  }
-  //----------------------------------------------------------------------------
-  /** %Print msg to Serial and halt.
-   *
-   * \param[in] msg Message to print.
-   */
-  void errorHalt(const __FlashStringHelper* msg) {
-    errorHalt(&Serial, msg);
-  }
-  //----------------------------------------------------------------------------
-  /** %Print error info to Serial and halt. */
-  void errorHalt() {errorHalt(&Serial);}
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt.
-   *
-   * \param[in] msg Message to print.
-   */
-  void errorHalt(const char* msg) {errorHalt(&Serial, msg);}
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt. */
-  void initErrorHalt() {initErrorHalt(&Serial);}
-  //----------------------------------------------------------------------------
-  /** %Print msg, any SD error code.
-   *
-   * \param[in] msg Message to print.
-   */
-  void errorPrint(const char* msg) {errorPrint(&Serial, msg);}
-   /** %Print msg, any SD error code.
-   *
-   * \param[in] msg Message to print.
-   */
-  void errorPrint(const __FlashStringHelper* msg) {errorPrint(&Serial, msg);}
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt.
-   *
-   * \param[in] msg Message to print.
-   */
-  void initErrorHalt(const char* msg) {initErrorHalt(&Serial, msg);}
-  //----------------------------------------------------------------------------
-  /** %Print error info and halt.
-   *
-   * \param[in] msg Message to print.
-   */
-  void initErrorHalt(const __FlashStringHelper* msg) {
-    initErrorHalt(&Serial, msg);
-  }
-#endif  // ENABLE_ARDUINO_SERIAL
-  //----------------------------------------------------------------------------
- private:
-  SdCard* m_card = nullptr;
-  SdCardFactory m_cardFactory;
-};
-//------------------------------------------------------------------------------
-/**
- * \class SdFat32
- * \brief SD file system class for FAT volumes.
- */
-class SdFat32 : public SdBase<FatVolume, FatFormatter> {
- public:
-};
-//------------------------------------------------------------------------------
-/**
- * \class SdExFat
- * \brief SD file system class for exFAT volumes.
- */
-class SdExFat : public SdBase<ExFatVolume, ExFatFormatter> {
- public:
-};
-//------------------------------------------------------------------------------
-/**
- * \class SdFs
- * \brief SD file system class for FAT16, FAT32, and exFAT volumes.
- */
-class SdFs : public SdBase<FsVolume, FsFormatter> {
- public:
-};
-//------------------------------------------------------------------------------
-#if SDFAT_FILE_TYPE == 1 || defined(DOXYGEN)
-/** Select type for SdFat. */
-typedef SdFat32 SdFat;
-/** Select type for SdBaseFile. */
-typedef FatFile SdBaseFile;
-#elif SDFAT_FILE_TYPE == 2
-typedef SdExFat SdFat;
-typedef ExFatFile SdBaseFile;
-#elif SDFAT_FILE_TYPE == 3
-typedef SdFs SdFat;
-typedef FsBaseFile SdBaseFile;
-#else  // SDFAT_FILE_TYPE
-#error Invalid SDFAT_FILE_TYPE
-#endif  // SDFAT_FILE_TYPE
-//
-// Only define File if FS.h is not included.
-// Line with test for __has_include must not have operators or parentheses.
-#if defined __has_include
-#if __has_include(<FS.h>)
-#define HAS_INCLUDE_FS_H
-#warning File not defined because __has_include(FS.h)
-#endif  // __has_include(<FS.h>)
-#endif  // defined __has_include
-#ifndef HAS_INCLUDE_FS_H
-#if SDFAT_FILE_TYPE == 1 || defined(DOXYGEN)
-/** Select type for File. */
-typedef File32 File;
-#elif SDFAT_FILE_TYPE == 2
-typedef ExFile File;
-#elif SDFAT_FILE_TYPE == 3
-typedef FsFile File;
-#endif  // SDFAT_FILE_TYPE
-#endif  // HAS_INCLUDE_FS_H
-/**
- * \class SdFile
- * \brief FAT16/FAT32 file with Print.
- */
-class SdFile : public PrintFile<SdBaseFile> {
- public:
-  SdFile() {}
-  /** Create an open SdFile.
-   * \param[in] path path for file.
-   * \param[in] oflag open flags.
-   */
-  SdFile(const char* path, oflag_t oflag) {
-    open(path, oflag);
-  }
-  /** Set the date/time callback function
-   *
-   * \param[in] dateTime The user's call back function.  The callback
-   * function is of the form:
-   *
-   * \code
-   * void dateTime(uint16_t* date, uint16_t* time) {
-   *   uint16_t year;
-   *   uint8_t month, day, hour, minute, second;
-   *
-   *   // User gets date and time from GPS or real-time clock here
-   *
-   *   // return date using FS_DATE macro to format fields
-   *   *date = FS_DATE(year, month, day);
-   *
-   *   // return time using FS_TIME macro to format fields
-   *   *time = FS_TIME(hour, minute, second);
-   * }
-   * \endcode
-   *
-   * Sets the function that is called when a file is created or when
-   * a file's directory entry is modified by sync(). All timestamps,
-   * access, creation, and modify, are set when a file is created.
-   * sync() maintains the last access date and last modify date/time.
-   *
-   */
-  static void dateTimeCallback(
-    void (*dateTime)(uint16_t* date, uint16_t* time)) {
-    FsDateTime::setCallback(dateTime);
-  }
-  /**  Cancel the date/time callback function. */
-  static void dateTimeCallbackCancel() {
-    FsDateTime::clearCallback();
-  }
-};
-#endif  // SdFat_h

lib/SdFat_NoArduino/src/SdFatConfig.h

@@ -1,435 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief configuration definitions
- */
-#ifndef SdFatConfig_h
-#define SdFatConfig_h
-#include <stdint.h>
-#ifdef __AVR__
-#include <avr/io.h>
-#endif  // __AVR__
-//
-// To try UTF-8 encoded filenames.
-// #define USE_UTF8_LONG_NAMES 1
-//
-// For minimum flash size use these settings:
-// #define USE_FAT_FILE_FLAG_CONTIGUOUS 0
-// #define ENABLE_DEDICATED_SPI 0
-// #define USE_LONG_FILE_NAMES 0
-// #define SDFAT_FILE_TYPE 1
-// #define CHECK_FLASH_PROGRAMMING 0  // May cause SD to sleep at high current.
-//
-// Options can be set in a makefile or an IDE like platformIO
-// if they are in a #ifndef/#endif block below.
-//------------------------------------------------------------------------------
-/** For Debug - must be one */
-#define ENABLE_ARDUINO_FEATURES 0
-/** For Debug - must be one */
-#define ENABLE_ARDUINO_SERIAL 0
-/** For Debug - must be one */
-#define ENABLE_ARDUINO_STRING 0
-//------------------------------------------------------------------------------
-#if ENABLE_ARDUINO_FEATURES
-#include "Arduino.h"
-#ifdef PLATFORM_ID
-// Only defined if a Particle device.
-#include "application.h"
-#endif  // PLATFORM_ID
-#else
-#define SS 0
-extern "C" unsigned long millis();
-#endif  // ENABLE_ARDUINO_FEATURES
-//------------------------------------------------------------------------------
-/**
- * File types for SdFat, File, SdFile, SdBaseFile, fstream,
- * ifstream, and ofstream.
- *
- * Set SDFAT_FILE_TYPE to:
- *
- * 1 for FAT16/FAT32, 2 for exFAT, 3 for FAT16/FAT32 and exFAT.
- */
-#ifndef SDFAT_FILE_TYPE
-#if defined(__AVR__) && FLASHEND < 0X8000
-// 32K AVR boards.
-#define SDFAT_FILE_TYPE 1
-#else  // defined(__AVR__) && FLASHEND < 0X8000
-// All other boards.
-#define SDFAT_FILE_TYPE 3
-#endif  // defined(__AVR__) && FLASHEND < 0X8000
-#endif  // SDFAT_FILE_TYPE
-//------------------------------------------------------------------------------
-/**
- * Set USE_FAT_FILE_FLAG_CONTIGUOUS nonzero to optimize access to
- * contiguous files.  A small amount of flash is flash is used.
- */
-#ifndef USE_FAT_FILE_FLAG_CONTIGUOUS
-#define USE_FAT_FILE_FLAG_CONTIGUOUS 1
-#endif  // USE_FAT_FILE_FLAG_CONTIGUOUS
-//------------------------------------------------------------------------------
-/**
- * Set ENABLE_DEDICATED_SPI non-zero to enable dedicated use of the SPI bus.
- * Selecting dedicated SPI in SdSpiConfig() will produce better
- * performance by using very large multi-block transfers to and
- * from the SD card.
- *
- * Enabling dedicated SPI will cost extra flash and RAM.
- */
-#ifndef ENABLE_DEDICATED_SPI
-#if defined(__AVR__) && FLASHEND < 0X8000
-// 32K AVR boards.
-#define ENABLE_DEDICATED_SPI 1
-#else  // defined(__AVR__) && FLASHEND < 0X8000
-// All other boards.
-#define ENABLE_DEDICATED_SPI 1
-#endif  // defined(__AVR__) && FLASHEND < 0X8000
-#endif  // ENABLE_DEDICATED_SPI
-//------------------------------------------------------------------------------
-// Driver options
-/**
- * If the symbol SPI_DRIVER_SELECT is:
- *
- * 0 - An optimized custom SPI driver is used if it exists
- *     else the standard library driver is used.
- *
- * 1 - The standard library driver is always used.
- *
- * 2 - An external SPI driver of SoftSpiDriver template class is always used.
- *
- * 3 - An external SPI driver derived from SdSpiBaseClass is always used.
- */
-#ifndef SPI_DRIVER_SELECT
-#define SPI_DRIVER_SELECT 0
-#endif  // SPI_DRIVER_SELECT
-/**
- * If USE_SPI_ARRAY_TRANSFER is non-zero and the standard SPI library is
- * use, the array transfer function, transfer(buf, size), will be used.
- * This option will allocate up to a 512 byte temporary buffer for send.
- * This may be faster for some boards.  Do not use this with AVR boards.
- */
-#ifndef USE_SPI_ARRAY_TRANSFER
-#define USE_SPI_ARRAY_TRANSFER 0
-#endif  // USE_SPI_ARRAY_TRANSFER
-/**
- * SD maximum initialization clock rate.
- */
-#ifndef SD_MAX_INIT_RATE_KHZ
-#define SD_MAX_INIT_RATE_KHZ 400
-#endif  // SD_MAX_INIT_RATE_KHZ
-/**
- * Set USE_BLOCK_DEVICE_INTERFACE nonzero to use a generic block device.
- * This allow use of an external FsBlockDevice driver that is derived from
- * the FsBlockDeviceInterface like this:
- *
- * class UsbMscDriver : public FsBlockDeviceInterface {
- *   ... code for USB mass storage class driver.
- * };
- *
- * UsbMscDriver usbMsc;
- * FsVolume key;
- * ...
- *
- *   // Init USB MSC driver.
- *   if (!usbMsc.begin()) {
- *     ... handle driver init failure.
- *   }
- *   // Init FAT/exFAT volume.
- *   if (!key.begin(&usbMsc)) {
- *     ... handle FAT/exFAT failure.
- *   }
- */
-#ifndef USE_BLOCK_DEVICE_INTERFACE
-#define USE_BLOCK_DEVICE_INTERFACE 0
-#endif  // USE_BLOCK_DEVICE_INTERFACE
- /**
- * SD_CHIP_SELECT_MODE defines how the functions
- * void sdCsInit(SdCsPin_t pin) {pinMode(pin, OUTPUT);}
- * and
- * void sdCsWrite(SdCsPin_t pin, bool level) {digitalWrite(pin, level);}
- * are defined.
- *
- * 0 - Internal definition is a strong symbol and can't be replaced.
- *
- * 1 - Internal definition is a weak symbol and can be replaced.
- *
- * 2 - No internal definition and must be defined in the application.
- */
-#ifndef SD_CHIP_SELECT_MODE
-#define SD_CHIP_SELECT_MODE 0
-#endif  // SD_CHIP_SELECT_MODE
-/** Type for card chip select pin. */
-typedef uint8_t SdCsPin_t;
-//------------------------------------------------------------------------------
-/**
- * Set USE_LONG_FILE_NAMES nonzero to use long file names (LFN) in FAT16/FAT32.
- * exFAT always uses long file names.
- *
- * Long File Name are limited to a maximum length of 255 characters.
- *
- * This implementation allows 7-bit characters in the range
- * 0X20 to 0X7E except the following characters are not allowed:
- *
- *  < (less than)
- *  > (greater than)
- *  : (colon)
- *  " (double quote)
- *  / (forward slash)
- *  \ (backslash)
- *  | (vertical bar or pipe)
- *  ? (question mark)
- *  * (asterisk)
- *
- */
-#ifndef USE_LONG_FILE_NAMES
-#define USE_LONG_FILE_NAMES 1
-#endif  // USE_LONG_FILE_NAMES
-/**
- * Set USE_UTF8_LONG_NAMES nonzero to use UTF-8 file names. Use of UTF-8 names
- * will require significantly more flash memory and a small amount of extra
- * RAM.
- *
- * UTF-8 filenames allow encoding of 1,112,064 code points in Unicode using
- * one to four one-byte (8-bit) code units.
- *
- * As of Version 13.0, the Unicode Standard defines 143,859 characters.
- *
- * getName() will return UTF-8 strings and printName() will write UTF-8 strings.
- */
-#ifndef USE_UTF8_LONG_NAMES
-#define USE_UTF8_LONG_NAMES 0
-#endif  // USE_UTF8_LONG_NAMES
-
-#if USE_UTF8_LONG_NAMES && !USE_LONG_FILE_NAMES
-#error "USE_UTF8_LONG_NAMES requires USE_LONG_FILE_NAMES to be non-zero."
-#endif  // USE_UTF8_LONG_NAMES && !USE_LONG_FILE_NAMES
-//------------------------------------------------------------------------------
-/**
- * Set MAINTAIN_FREE_CLUSTER_COUNT nonzero to keep the count of free clusters
- * updated.  This will increase the speed of the freeClusterCount() call
- * after the first call.  Extra flash will be required.
- */
-#ifndef MAINTAIN_FREE_CLUSTER_COUNT
-#define MAINTAIN_FREE_CLUSTER_COUNT 0
-#endif  // MAINTAIN_FREE_CLUSTER_COUNT
-//------------------------------------------------------------------------------
-/**
- * Set the default file time stamp when a RTC callback is not used.
- * A valid date and time is required by the FAT/exFAT standard.
- *
- * The default below is YYYY-01-01 00:00:00 midnight where YYYY is
- * the compile year from the __DATE__ macro.  This is easy to recognize
- * as a placeholder for a correct date/time.
- *
- * The full compile date is:
- * FS_DATE(compileYear(), compileMonth(), compileDay())
- *
- * The full compile time is:
- * FS_TIME(compileHour(), compileMinute(), compileSecond())
- */
-#define FS_DEFAULT_DATE FS_DATE(compileYear(), 1, 1)
-/** 00:00:00 midnight */
-#define FS_DEFAULT_TIME FS_TIME(0, 0, 0)
-//------------------------------------------------------------------------------
-/**
- * If CHECK_FLASH_PROGRAMMING is zero, overlap of single sector flash
- * programming and other operations will be allowed for faster write
- * performance.
- *
- * Some cards will not sleep in low power mode unless CHECK_FLASH_PROGRAMMING
- * is non-zero.
- */
-#ifndef CHECK_FLASH_PROGRAMMING
-#define CHECK_FLASH_PROGRAMMING 1
-#endif  // CHECK_FLASH_PROGRAMMING
-//------------------------------------------------------------------------------
-/**
- * To enable SD card CRC checking for SPI, set USE_SD_CRC nonzero.
- *
- * Set USE_SD_CRC to 1 to use a smaller CRC-CCITT function.  This function
- * is slower for AVR but may be fast for ARM and other processors.
- *
- * Set USE_SD_CRC to 2 to used a larger table driven CRC-CCITT function.  This
- * function is faster for AVR but may be slower for ARM and other processors.
- */
-#ifndef USE_SD_CRC
-#define USE_SD_CRC 0
-#endif  // USE_SD_CRC
-//------------------------------------------------------------------------------
-/** If the symbol USE_FCNTL_H is nonzero, open flags for access modes O_RDONLY,
- * O_WRONLY, O_RDWR and the open modifiers O_APPEND, O_CREAT, O_EXCL, O_SYNC
- * will be defined by including the system file fcntl.h.
- */
-#ifndef USE_FCNTL_H
-#if defined(__AVR__)
-// AVR fcntl.h does not define open flags.
-#define USE_FCNTL_H 0
-#elif defined(PLATFORM_ID)
-// Particle boards - use fcntl.h.
-#define USE_FCNTL_H 1
-#elif defined(__arm__)
-// ARM gcc defines open flags.
-#define USE_FCNTL_H 1
-#elif defined(ESP32)
-#define USE_FCNTL_H 1
-#else  // defined(__AVR__)
-#define USE_FCNTL_H 0
-#endif  // defined(__AVR__)
-#endif  // USE_FCNTL_H
-//------------------------------------------------------------------------------
-/**
- * Set INCLUDE_SDIOS nonzero to include sdios.h in SdFat.h.
- * sdios.h provides C++ style IO Streams.
- */
-#ifndef INCLUDE_SDIOS
-#define INCLUDE_SDIOS 0
-#endif  // INCLUDE_SDIOS
-//------------------------------------------------------------------------------
-/**
- * Set FAT12_SUPPORT nonzero to enable use if FAT12 volumes.
- * FAT12 has not been well tested and requires additional flash.
- */
-#ifndef FAT12_SUPPORT
-#define FAT12_SUPPORT 0
-#endif  // FAT12_SUPPORT
-//------------------------------------------------------------------------------
-/**
- * Set DESTRUCTOR_CLOSES_FILE nonzero to close a file in its destructor.
- *
- * Causes use of lots of heap in ARM.
- */
-#ifndef DESTRUCTOR_CLOSES_FILE
-#define DESTRUCTOR_CLOSES_FILE 0
-#endif  // DESTRUCTOR_CLOSES_FILE
-//------------------------------------------------------------------------------
-/**
- * Call flush for endl if ENDL_CALLS_FLUSH is nonzero
- *
- * The standard for iostreams is to call flush.  This is very costly for
- * SdFat.  Each call to flush causes 2048 bytes of I/O to the SD.
- *
- * SdFat has a single 512 byte buffer for SD I/O so it must write the current
- * data sector to the SD, read the directory sector from the SD, update the
- * directory entry, write the directory sector to the SD and read the data
- * sector back into the buffer.
- *
- * The SD flash memory controller is not designed for this many rewrites
- * so performance may be reduced by more than a factor of 100.
- *
- * If ENDL_CALLS_FLUSH is zero, you must call flush and/or close to force
- * all data to be written to the SD.
- */
-#ifndef ENDL_CALLS_FLUSH
-#define ENDL_CALLS_FLUSH 0
-#endif  // ENDL_CALLS_FLUSH
-//------------------------------------------------------------------------------
-/**
- * Set USE_SIMPLE_LITTLE_ENDIAN nonzero for little endian processors
- * with no memory alignment restrictions.
- */
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__\
-  && (defined(__AVR__) || defined(__ARM_FEATURE_UNALIGNED))
-#define USE_SIMPLE_LITTLE_ENDIAN 1
-#else  // __BYTE_ORDER_
-#define USE_SIMPLE_LITTLE_ENDIAN 0
-#endif  // __BYTE_ORDER_
-//------------------------------------------------------------------------------
-/**
- * Set USE_SEPARATE_FAT_CACHE nonzero to use a second 512 byte cache
- * for FAT16/FAT32 table entries.  This improves performance for large
- * writes that are not a multiple of 512 bytes.
- */
-#ifdef __arm__
-#define USE_SEPARATE_FAT_CACHE 1
-#else  // __arm__
-#define USE_SEPARATE_FAT_CACHE 0
-#endif  // __arm__
-//------------------------------------------------------------------------------
-/**
- * Set USE_EXFAT_BITMAP_CACHE nonzero to use a second 512 byte cache
- * for exFAT bitmap entries.  This improves performance for large
- * writes that are not a multiple of 512 bytes.
- */
-#ifdef __arm__
-#define USE_EXFAT_BITMAP_CACHE 1
-#else  // __arm__
-#define USE_EXFAT_BITMAP_CACHE 0
-#endif  // __arm__
-//------------------------------------------------------------------------------
-/**
- * Set USE_MULTI_SECTOR_IO nonzero to use multi-sector SD read/write.
- *
- * Don't use mult-sector read/write on small AVR boards.
- */
-#if defined(RAMEND) && RAMEND < 3000
-#define USE_MULTI_SECTOR_IO 0
-#else  // RAMEND
-#define USE_MULTI_SECTOR_IO 1
-#endif  // RAMEND
-//------------------------------------------------------------------------------
-/** Enable SDIO driver if available. */
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-// Pseudo pin select for SDIO.
-#ifndef BUILTIN_SDCARD
-#define BUILTIN_SDCARD 254
-#endif  // BUILTIN_SDCARD
-// SPI for built-in card.
-#ifndef SDCARD_SPI
-#define SDCARD_SPI      SPI1
-#define SDCARD_MISO_PIN 59
-#define SDCARD_MOSI_PIN 61
-#define SDCARD_SCK_PIN  60
-#define SDCARD_SS_PIN   62
-#endif  // SDCARD_SPI
-#define HAS_SDIO_CLASS 1
-#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
-#if defined(__IMXRT1062__)
-#define HAS_SDIO_CLASS 1
-#endif  // defined(__IMXRT1062__)
-//------------------------------------------------------------------------------
-/**
- * Determine the default SPI configuration.
- */
-#if defined(ARDUINO_ARCH_APOLLO3)\
-  || (defined(__AVR__) && defined(SPDR) && defined(SPSR) && defined(SPIF))\
-  || (defined(__AVR__) && defined(SPI0) && defined(SPI_RXCIF_bm))\
-  || defined(ESP8266) || defined(ESP32)\
-  || defined(PLATFORM_ID)\
-  || defined(ARDUINO_SAM_DUE)\
-  || defined(STM32_CORE_VERSION)\
-  || defined(__STM32F1__) || defined(__STM32F4__)\
-  || (defined(CORE_TEENSY) && defined(__arm__))
-#define SD_HAS_CUSTOM_SPI 1
-#else  // SD_HAS_CUSTOM_SPI
-// Use standard SPI library.
-#define SD_HAS_CUSTOM_SPI 0
-#endif  // SD_HAS_CUSTOM_SPI
-//------------------------------------------------------------------------------
-#ifndef HAS_SDIO_CLASS
-/** Default is no SDIO. */
-#define HAS_SDIO_CLASS 0
-#endif  // HAS_SDIO_CLASS
-
-#endif  // SdFatConfig_h

lib/SdFat_NoArduino/src/SpiDriver/SdSpiArduinoDriver.h

@@ -1,96 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief SpiDriver classes for Arduino compatible systems.
- */
-#ifndef SdSpiArduinoDriver_h
-#define SdSpiArduinoDriver_h
-//==============================================================================
-#if SPI_DRIVER_SELECT == 0 && SD_HAS_CUSTOM_SPI
-#define SD_USE_CUSTOM_SPI
-#endif  // SPI_DRIVER_SELECT == 0 && SD_HAS_CUSTOM_SPI
-/**
- * \class SdSpiArduinoDriver
- * \brief Optimized SPI class for access to SD and SDHC flash memory cards.
- */
-class SdSpiArduinoDriver {
- public:
-  /** Activate SPI hardware. */
-  void activate();
-  /** Initialize the SPI bus.
-   *
-   * \param[in] spiConfig SD card configuration.
-   */
-  void begin(SdSpiConfig spiConfig);
-  /** Deactivate SPI hardware. */
-  void deactivate();
-  /** End use of SPI driver after begin() call. */
-  void end();
-  /** Receive a byte.
-   *
-   * \return The byte.
-   */
-  uint8_t receive();
-  /** Receive multiple bytes.
-  *
-  * \param[out] buf Buffer to receive the data.
-  * \param[in] count Number of bytes to receive.
-  *
-  * \return Zero for no error or nonzero error code.
-  */
-  uint8_t receive(uint8_t* buf, size_t count);
-  /** Send a byte.
-   *
-   * \param[in] data Byte to send
-   */
-  void send(uint8_t data);
-  /** Send multiple bytes.
-   *
-   * \param[in] buf Buffer for data to be sent.
-   * \param[in] count Number of bytes to send.
-   */
-  void send(const uint8_t* buf, size_t count);
-  /** Save high speed SPISettings after SD initialization.
-   *
-   * \param[in] maxSck Maximum SCK frequency.
-   */
-  void setSckSpeed(uint32_t maxSck) {
-    m_spiSettings = SPISettings(maxSck, MSBFIRST, SPI_MODE0);
-  }
-
- private:
-  SPIClass *m_spi;
-  SPISettings m_spiSettings;
-};
-/** Typedef for use of SdSpiArduinoDriver */
-typedef SdSpiArduinoDriver SdSpiDriver;
-//------------------------------------------------------------------------------
-#ifndef SD_USE_CUSTOM_SPI
-#include "SdSpiLibDriver.h"
-#elif defined(__AVR__)
-#include "SdSpiAvr.h"
-#endif  // __AVR__
-#endif  // SdSpiArduinoDriver_h

lib/SdFat_NoArduino/src/SpiDriver/SdSpiArtemis.cpp

@@ -1,79 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "SdSpiDriver.h"
-#if defined(SD_USE_CUSTOM_SPI) && defined(ARDUINO_ARCH_APOLLO3)
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::activate() {
-  m_spi->beginTransaction(m_spiSettings);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  if (spiConfig.spiPort) {
-    m_spi = spiConfig.spiPort;
-  } else {
-    m_spi = &SPI;
-  }
-  m_spi->begin();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::deactivate() {
-  m_spi->endTransaction();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::end() {
-  m_spi->end();
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive() {
-  return m_spi->transfer(0XFF);
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-  memset(buf, 0XFF, count);
-  m_spi->transfer(buf, count);
-  return 0;
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(uint8_t data) {
-  m_spi->transfer(data);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(const uint8_t* buf, size_t count) {
-  // If not a multiple of four.  Command with CRC used six byte send.
-  while (count%4) {
-    send(*buf++);
-    count--;
-  }
-  // Convert byte array to 4 byte array.
-  uint32_t myArray[count/4]; // NOLINT
-  for (int x = 0; x < count/4; x++) {
-    myArray[x] = ((uint32_t)buf[(x * 4) + 3] << (8 * 3)) |
-                 ((uint32_t)buf[(x * 4) + 2] << (8 * 2)) |
-                 ((uint32_t)buf[(x * 4) + 1] << (8 * 1)) |
-                 ((uint32_t)buf[(x * 4) + 0] << (8 * 0));
-  }
-  m_spi->transfer(reinterpret_cast<void *>(myArray), count);
-}
-#endif  // defined(SD_USE_CUSTOM_SPI) && defined(ARDUINO_ARCH_APOLLO3)

lib/SdFat_NoArduino/src/SpiDriver/SdSpiAvr.h

@@ -1,124 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef SdSpiAvr_h
-#define SdSpiAvr_h
-// Use of in-line for AVR to save flash.
-#define nop asm volatile ("nop\n\t")
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::activate() {
-  SPI.beginTransaction(m_spiSettings);
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  (void)spiConfig;
-  SPI.begin();
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::deactivate() {
-  SPI.endTransaction();
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::end() {
-  SPI.end();
-}
-//------------------------------------------------------------------------------
-inline uint8_t SdSpiArduinoDriver::receive() {
-  return SPI.transfer(0XFF);
-}
-//------------------------------------------------------------------------------
-inline uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-  if (count == 0) {
-    return 0;
-  }
-#ifdef SPSR
-  SPDR = 0XFF;
-  while (--count) {
-    // nops optimize loop for 16MHz CPU 8 MHz SPI
-    nop;
-    nop;
-    while (!(SPSR & _BV(SPIF))) {}
-    uint8_t in = SPDR;
-    SPDR = 0XFF;
-    *buf++ = in;
-  }
-  while (!(SPSR & _BV(SPIF))) {}
-  *buf = SPDR;
-#elif defined(SPI_RXCIF_bm)
-  SPI0.DATA = 0XFF;
-  while (--count) {
-    // nops optimize loop for ATmega4809 16MHz CPU 8 MHz SPI
-    nop;
-    nop;
-    nop;
-    nop;
-    while (!(SPI0.INTFLAGS & SPI_RXCIF_bm)) {}
-    uint8_t in = SPI0.DATA;
-    SPI0.DATA = 0XFF;
-    *buf++ = in;
-  }
-  while (!(SPI0.INTFLAGS & SPI_RXCIF_bm)) {}
-  *buf = SPI0.DATA;
-#else  // SPSR
-#error Unsupported AVR CPU - edit SdFatConfig.h to use standard SPI library.
-#endif  // SPSR
-  return 0;
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::send(uint8_t data) {
-  SPI.transfer(data);
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::send(const uint8_t* buf , size_t count) {
-  if (count == 0) {
-    return;
-  }
-#ifdef SPSR
-  SPDR = *buf++;
-  while (--count) {
-    uint8_t b = *buf++;
-    // nops optimize loop for 16MHz CPU 8 MHz SPI
-    nop;
-    nop;
-    while (!(SPSR & (1 << SPIF))) {}
-    SPDR = b;
-  }
-  while (!(SPSR & (1 << SPIF))) {}
-#elif defined(SPI_RXCIF_bm)
-  SPI0.DATA = *buf++;
-  while (--count) {
-    uint8_t b = *buf++;
-    // nops optimize loop for ATmega4809 16MHz CPU 8 MHz SPI
-    nop;
-    nop;
-    nop;
-    while (!(SPI0.INTFLAGS & SPI_RXCIF_bm)) {}
-    SPI0.DATA = b;
-  }
-  while (!(SPI0.INTFLAGS & SPI_RXCIF_bm)) {}
-#else  // SPSR
-#error Unsupported AVR CPU - edit SdFatConfig.h to use standard SPI library.
-#endif  // SPSR
-}
-#endif  // SdSpiAvr_h

lib/SdFat_NoArduino/src/SpiDriver/SdSpiBareUnoDriver.h

@@ -1,200 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef SdSpiBareUnoDriver_h
-#define SdSpiBareUnoDriver_h
-/**
- * \file
- * \brief Driver to test with no Arduino includes.
- */
-
-#include <avr/interrupt.h>
-#include "../common/SysCall.h"
-#define nop asm volatile ("nop\n\t")
-#ifndef HIGH
-#define HIGH 1
-#endif  // HIGH
-#ifndef LOW
-#define LOW 0
-#endif  // LOW
-#ifndef INPUT
-#define INPUT 0
-#endif  // INPUT
-#ifndef OUTPUT
-#define OUTPUT 1
-#endif  // OUTPUT
-
-inline uint8_t unoBit(uint8_t pin) {
-  return 1 << (pin < 8 ? pin : pin < 14 ? pin - 8 : pin - 14);
-}
-inline uint8_t unoDigitalRead(uint8_t pin) {
-  volatile uint8_t* reg = pin < 8 ? &PIND : pin < 14 ? &PINB : &PINC;
-  return *reg & unoBit(pin);
-}
-inline void unoDigitalWrite(uint8_t pin, uint8_t value) {
-  volatile uint8_t* port = pin < 8 ? &PORTD : pin < 14 ? &PORTB : &PORTC;
-  uint8_t bit = unoBit(pin);
-  cli();
-  if (value) {
-    *port |= bit;
-  } else {
-    *port &= ~bit;
-  }
-  sei();
-}
-
-inline void unoPinMode(uint8_t pin, uint8_t mode) {
-  uint8_t bit = unoBit(pin);
-  volatile uint8_t* reg = pin < 8 ? &DDRD : pin < 14 ? &DDRB : &DDRC;
-
-  cli();
-  if (mode == OUTPUT) {
-    *reg |= bit;
-  } else {
-    *reg &= ~bit;
-    // handle INPUT pull-up
-    unoDigitalWrite(pin, mode != INPUT);
-  }
-  sei();
-}
-
-#define UNO_SS   10
-#define UNO_MOSI 11
-#define UNO_MISO 12
-#define UNO_SCK  13
-//------------------------------------------------------------------------------
-/**
- * \class SdSpiDriverBareUno
- * \brief Optimized SPI class for access to SD and SDHC flash memory cards.
- */
-class SdSpiDriverBareUno {
- public:
-  /** Activate SPI hardware. */
-  void activate() {}
-  /** Initialize the SPI bus.
-   *
-   * \param[in] spiConfig SD card configuration.
-   */
-  void begin(SdSpiConfig spiConfig) {
-    m_csPin = spiConfig.csPin;
-    unoPinMode(m_csPin, OUTPUT);
-    unoDigitalWrite(m_csPin, HIGH);
-    unoDigitalWrite(UNO_SS, HIGH);
-    unoPinMode(UNO_SS, OUTPUT);
-    SPCR |= _BV(MSTR);
-    SPCR |= _BV(SPE);
-    SPSR = 0;
-    unoPinMode(UNO_SCK, OUTPUT);
-    unoPinMode(UNO_MOSI, OUTPUT);
-  }
-  /** Deactivate SPI hardware. */
-  void deactivate() {}
-  /** deactivate SPI driver. */
-  void end() {}
-  /** Receive a byte.
-   *
-   * \return The byte.
-   */
-  uint8_t receive() {
-    return transfer(0XFF);
-  }
-  /** Receive multiple bytes.
-  *
-  * \param[out] buf Buffer to receive the data.
-  * \param[in] count Number of bytes to receive.
-  *
-  * \return Zero for no error or nonzero error code.
-  */
-  uint8_t receive(uint8_t* buf, size_t count) {
-    if (count == 0) {
-      return 0;
-    }
-    uint8_t* pr = buf;
-    SPDR = 0XFF;
-    while (--count > 0) {
-      while (!(SPSR & _BV(SPIF))) {}
-      uint8_t in = SPDR;
-      SPDR = 0XFF;
-      *pr++ = in;
-      // nops to optimize loop for 16MHz CPU 8 MHz SPI
-      nop;
-      nop;
-    }
-    while (!(SPSR & _BV(SPIF))) {}
-    *pr = SPDR;
-    return 0;
-  }
-  /** Send a byte.
-   *
-   * \param[in] data Byte to send
-   */
-  void send(uint8_t data) {
-    transfer(data);
-  }
-  /** Send multiple bytes.
-   *
-   * \param[in] buf Buffer for data to be sent.
-   * \param[in] count Number of bytes to send.
-   */
-  void send(const uint8_t* buf, size_t count) {
-    if (count == 0) {
-      return;
-    }
-    SPDR = *buf++;
-    while (--count > 0) {
-      uint8_t b = *buf++;
-      while (!(SPSR & (1 << SPIF))) {}
-      SPDR = b;
-      // nops to optimize loop for 16MHz CPU 8 MHz SPI
-      nop;
-      nop;
-    }
-    while (!(SPSR & (1 << SPIF))) {}
-  }
-  /** Set CS low. */
-  void select() {
-     unoDigitalWrite(m_csPin, LOW);
-  }
-  /** Save high speed SPISettings after SD initialization.
-   *
-   * \param[in] spiConfig SPI options.
-   */
-  void setSckSpeed(uint32_t maxSck) {
-    (void)maxSck;
-    SPSR |= 1 << SPI2X;
-  }
-  static uint8_t transfer(uint8_t data) {
-    SPDR = data;
-    while (!(SPSR & _BV(SPIF))) {}  // wait
-    return SPDR;
-  }
-  /** Set CS high. */
-  void unselect() {
-    unoDigitalWrite(m_csPin, HIGH);
-  }
-
- private:
-  SdCsPin_t m_csPin;
-};
-#endif  // SdSpiBareUnoDriver_h

lib/SdFat_NoArduino/src/SpiDriver/SdSpiBaseClass.h

@@ -1,78 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief Base class for external SPI driver.
- */
-#ifndef SdSpiBaseClass_h
-#define SdSpiBaseClass_h
-/**
- * \class SdSpiBaseClass
- * \brief Base class for external SPI drivers
- */
-class SdSpiBaseClass {
- public:
-  /** Activate SPI hardware. */
-  virtual void activate() {}
-  /** Initialize the SPI bus.
-   *
-   * \param[in] config SPI configuration.
-   */
-  virtual void begin(SdSpiConfig config) = 0;
-  /** Deactivate SPI hardware. */
-  virtual void deactivate() {}
-  /** deactivate SPI driver. */
-  virtual void end() {}
-  /** Receive a byte.
-   *
-   * \return The byte.
-   */
-  virtual uint8_t receive() = 0;
-  /** Receive multiple bytes.
-  *
-  * \param[out] buf Buffer to receive the data.
-  * \param[in] count Number of bytes to receive.
-  *
-  * \return Zero for no error or nonzero error code.
-  */
-  virtual uint8_t receive(uint8_t* buf, size_t count) = 0;
-  /** Send a byte.
-   *
-   * \param[in] data Byte to send
-   */
-  virtual void send(uint8_t data) = 0;
-  /** Send multiple bytes.
-   *
-   * \param[in] buf Buffer for data to be sent.
-   * \param[in] count Number of bytes to send.
-   */
-  virtual void send(const uint8_t* buf, size_t count) = 0;
-  /** Save high speed SPISettings after SD initialization.
-   *
-   * \param[in] maxSck Maximum SCK frequency.
-   */
-  virtual void setSckSpeed(uint32_t maxSck) {(void)maxSck;}
-};
-#endif  // SdSpiBaseClass_h

lib/SdFat_NoArduino/src/SpiDriver/SdSpiChipSelect.cpp

@@ -1,48 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "SdSpiDriver.h"
-#if ENABLE_ARDUINO_FEATURES
-#if SD_CHIP_SELECT_MODE == 0
-//------------------------------------------------------------------------------
-void sdCsInit(SdCsPin_t pin) {
-  pinMode(pin, OUTPUT);
-}
-//------------------------------------------------------------------------------
-void sdCsWrite(SdCsPin_t pin, bool level) {
-  digitalWrite(pin, level);
-}
-#elif SD_CHIP_SELECT_MODE == 1
-//------------------------------------------------------------------------------
-__attribute__((weak))
-void sdCsInit(SdCsPin_t pin) {
-  pinMode(pin, OUTPUT);
-}
-//------------------------------------------------------------------------------
-__attribute__((weak))
-void sdCsWrite(SdCsPin_t pin, bool level) {
-  digitalWrite(pin, level);
-}
-#endif  // SD_CHIP_SELECT_MODE == 0
-#endif  // ENABLE_ARDUINO_FEATURES

lib/SdFat_NoArduino/src/SpiDriver/SdSpiDriver.h

@@ -1,155 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief SpiDriver classes
- */
-#ifndef SdSpiDriver_h
-#define SdSpiDriver_h
-#include "../common/SysCall.h"
-/**
- * Initialize SD chip select pin.
- *
- * \param[in] pin SD card chip select pin.
- */
-void sdCsInit(SdCsPin_t pin);
-/**
- * Initialize SD chip select pin.
- *
- * \param[in] pin SD card chip select pin.
- * \param[in] level SD card chip select level.
- */
-void sdCsWrite(SdCsPin_t pin, bool level);
-//------------------------------------------------------------------------------
-/** SPI bus is share with other devices. */
-const uint8_t SHARED_SPI = 0;
-#if ENABLE_DEDICATED_SPI
-/** The SD is the only device on the SPI bus. */
-const uint8_t DEDICATED_SPI = 1;
-/**
- * \param[in] opt option field of SdSpiConfig.
- * \return true for dedicated SPI.
- */
-inline bool spiOptionDedicated(uint8_t opt) {return opt & DEDICATED_SPI;}
-#else  // ENABLE_DEDICATED_SPI
-/**
- * \param[in] opt option field of SdSpiConfig.
- * \return true for dedicated SPI.
- */
-inline bool spiOptionDedicated(uint8_t opt) {(void)opt; return false;}
-#endif  // ENABLE_DEDICATED_SPI
-//------------------------------------------------------------------------------
-/** SPISettings for SCK frequency in Hz. */
-#define SD_SCK_HZ(maxSpeed) (maxSpeed)
-/** SPISettings for SCK frequency in MHz. */
-#define SD_SCK_MHZ(maxMhz) (1000000UL*(maxMhz))
-// SPI divisor constants - obsolete.
-/** Set SCK to max rate. */
-#define SPI_FULL_SPEED SD_SCK_MHZ(50)
-/** Set SCK rate to 16 MHz for Due */
-#define SPI_DIV3_SPEED SD_SCK_MHZ(16)
-/** Set SCK rate to 4 MHz for AVR. */
-#define SPI_HALF_SPEED SD_SCK_MHZ(4)
-/** Set SCK rate to 8 MHz for Due */
-#define SPI_DIV6_SPEED SD_SCK_MHZ(8)
-/** Set SCK rate to 2 MHz for AVR. */
-#define SPI_QUARTER_SPEED SD_SCK_MHZ(2)
-/** Set SCK rate to 1 MHz for AVR. */
-#define SPI_EIGHTH_SPEED SD_SCK_MHZ(1)
-/** Set SCK rate to 500 kHz for AVR. */
-#define SPI_SIXTEENTH_SPEED SD_SCK_HZ(500000)
-//------------------------------------------------------------------------------
-#if SPI_DRIVER_SELECT < 2
-#include "SPI.h"
-/** Port type for Arduino SPI hardware driver. */
-typedef SPIClass SpiPort_t;
-#elif SPI_DRIVER_SELECT == 2
-class SdSpiSoftDriver;
-/** Port type for software SPI driver. */
-typedef SdSpiSoftDriver SpiPort_t;
-#elif SPI_DRIVER_SELECT == 3
-class SdSpiBaseClass;
-/** Port type for extrernal SPI driver. */
-typedef SdSpiBaseClass SpiPort_t;
-#else  // SPI_DRIVER_SELECT
-typedef void*  SpiPort_t;
-#endif  // SPI_DRIVER_SELECT
-//------------------------------------------------------------------------------
-/**
- * \class SdSpiConfig
- * \brief SPI card configuration.
- */
-class SdSpiConfig {
- public:
-   /** SdSpiConfig constructor.
-   *
-   * \param[in] cs Chip select pin.
-   * \param[in] opt Options.
-   * \param[in] maxSpeed Maximum SCK frequency.
-   * \param[in] port The SPI port to use.
-   */
-  SdSpiConfig(SdCsPin_t cs, uint8_t opt, uint32_t maxSpeed, SpiPort_t* port) :
-    csPin(cs), options(opt), maxSck(maxSpeed), spiPort(port) {}
-
-  /** SdSpiConfig constructor.
-   *
-   * \param[in] cs Chip select pin.
-   * \param[in] opt Options.
-   * \param[in] maxSpeed Maximum SCK frequency.
-   */
-  SdSpiConfig(SdCsPin_t cs, uint8_t opt, uint32_t maxSpeed) :
-    csPin(cs), options(opt), maxSck(maxSpeed) {}
-  /** SdSpiConfig constructor.
-   *
-   * \param[in] cs Chip select pin.
-   * \param[in] opt Options.
-   */
-  SdSpiConfig(SdCsPin_t cs, uint8_t opt) : csPin(cs), options(opt) {}
-  /** SdSpiConfig constructor.
-   *
-   * \param[in] cs Chip select pin.
-   */
-  explicit SdSpiConfig(SdCsPin_t cs) : csPin(cs) {}
-
-  /** Chip select pin. */
-  const SdCsPin_t csPin;
-  /** Options */
-  const uint8_t options = SHARED_SPI;
-  /** Max SCK frequency */
-  const uint32_t maxSck = SD_SCK_MHZ(50);
-  /** SPI port */
-  SpiPort_t* spiPort = nullptr;
-};
-#if SPI_DRIVER_SELECT < 2
-#include "SdSpiArduinoDriver.h"
-#elif SPI_DRIVER_SELECT == 2
-#include "SdSpiSoftDriver.h"
-#elif SPI_DRIVER_SELECT == 3
-#include "SdSpiBaseClass.h"
-typedef SdSpiBaseClass SdSpiDriver;
-#else  // SPI_DRIVER_SELECT
-#error Invalid SPI_DRIVER_SELECT
-#endif  // SPI_DRIVER_SELECT
-#endif  // SdSpiDriver_h

lib/SdFat_NoArduino/src/SpiDriver/SdSpiDue.cpp

@@ -1,216 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "SdSpiDriver.h"
-#if defined(SD_USE_CUSTOM_SPI) && defined(ARDUINO_SAM_DUE)
-/* Use SAM3X DMAC if nonzero */
-#define USE_SAM3X_DMAC 1
-/* Use extra Bus Matrix arbitration fix if nonzero */
-#define USE_SAM3X_BUS_MATRIX_FIX 1
-/* Time in ms for DMA receive timeout */
-#define SAM3X_DMA_TIMEOUT 100
-/* chip select register number */
-#define SPI_CHIP_SEL 3
-/* DMAC receive channel */
-#define SPI_DMAC_RX_CH 1
-/* DMAC transmit channel */
-#define SPI_DMAC_TX_CH 0
-/* DMAC Channel HW Interface Number for SPI TX. */
-#define SPI_TX_IDX 1
-/* DMAC Channel HW Interface Number for SPI RX. */
-#define SPI_RX_IDX 2
-//------------------------------------------------------------------------------
-/* Disable DMA Controller. */
-static void dmac_disable() {
-  DMAC->DMAC_EN &= (~DMAC_EN_ENABLE);
-}
-/* Enable DMA Controller. */
-static void dmac_enable() {
-  DMAC->DMAC_EN = DMAC_EN_ENABLE;
-}
-/* Disable DMA Channel. */
-static void dmac_channel_disable(uint32_t ul_num) {
-  DMAC->DMAC_CHDR = DMAC_CHDR_DIS0 << ul_num;
-}
-/* Enable DMA Channel. */
-static void dmac_channel_enable(uint32_t ul_num) {
-  DMAC->DMAC_CHER = DMAC_CHER_ENA0 << ul_num;
-}
-/* Poll for transfer complete. */
-static bool dmac_channel_transfer_done(uint32_t ul_num) {
-  return (DMAC->DMAC_CHSR & (DMAC_CHSR_ENA0 << ul_num)) ? false : true;
-}
-//------------------------------------------------------------------------------
-// start RX DMA
-static void spiDmaRX(uint8_t* dst, uint16_t count) {
-  dmac_channel_disable(SPI_DMAC_RX_CH);
-  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_SADDR = (uint32_t)&SPI0->SPI_RDR;
-  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_DADDR = (uint32_t)dst;
-  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_DSCR =  0;
-  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CTRLA = count |
-      DMAC_CTRLA_SRC_WIDTH_BYTE | DMAC_CTRLA_DST_WIDTH_BYTE;
-  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CTRLB = DMAC_CTRLB_SRC_DSCR |
-      DMAC_CTRLB_DST_DSCR | DMAC_CTRLB_FC_PER2MEM_DMA_FC |
-      DMAC_CTRLB_SRC_INCR_FIXED | DMAC_CTRLB_DST_INCR_INCREMENTING;
-  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CFG = DMAC_CFG_SRC_PER(SPI_RX_IDX) |
-      DMAC_CFG_SRC_H2SEL | DMAC_CFG_SOD | DMAC_CFG_FIFOCFG_ASAP_CFG;
-  dmac_channel_enable(SPI_DMAC_RX_CH);
-}
-//------------------------------------------------------------------------------
-// start TX DMA
-static void spiDmaTX(const uint8_t* src, uint16_t count) {
-  static uint8_t ff = 0XFF;
-  uint32_t src_incr = DMAC_CTRLB_SRC_INCR_INCREMENTING;
-  if (!src) {
-    src = &ff;
-    src_incr = DMAC_CTRLB_SRC_INCR_FIXED;
-  }
-  dmac_channel_disable(SPI_DMAC_TX_CH);
-  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_SADDR = (uint32_t)src;
-  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_DADDR = (uint32_t)&SPI0->SPI_TDR;
-  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_DSCR =  0;
-  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CTRLA = count |
-      DMAC_CTRLA_SRC_WIDTH_BYTE | DMAC_CTRLA_DST_WIDTH_BYTE;
-
-  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CTRLB =  DMAC_CTRLB_SRC_DSCR |
-      DMAC_CTRLB_DST_DSCR | DMAC_CTRLB_FC_MEM2PER_DMA_FC |
-      src_incr | DMAC_CTRLB_DST_INCR_FIXED;
-
-  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CFG = DMAC_CFG_DST_PER(SPI_TX_IDX) |
-      DMAC_CFG_DST_H2SEL | DMAC_CFG_SOD | DMAC_CFG_FIFOCFG_ALAP_CFG;
-
-  dmac_channel_enable(SPI_DMAC_TX_CH);
-}
-//------------------------------------------------------------------------------
-//  initialize SPI controller
-void SdSpiArduinoDriver::activate() {
-  SPI.beginTransaction(m_spiSettings);
-
-  Spi* pSpi = SPI0;
-  // Save the divisor
-  uint32_t scbr = pSpi->SPI_CSR[SPI_CHIP_SEL] & 0XFF00;
-  // Disable SPI
-  pSpi->SPI_CR = SPI_CR_SPIDIS;
-  // reset SPI
-  pSpi->SPI_CR = SPI_CR_SWRST;
-  // no mode fault detection, set master mode
-  pSpi->SPI_MR = SPI_PCS(SPI_CHIP_SEL) | SPI_MR_MODFDIS | SPI_MR_MSTR;
-  // mode 0, 8-bit,
-  pSpi->SPI_CSR[SPI_CHIP_SEL] = scbr | SPI_CSR_CSAAT | SPI_CSR_NCPHA;
-  // enable SPI
-  pSpi->SPI_CR |= SPI_CR_SPIEN;
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  (void)spiConfig;
-  SPI.begin();
-#if USE_SAM3X_DMAC
-  pmc_enable_periph_clk(ID_DMAC);
-  dmac_disable();
-  DMAC->DMAC_GCFG = DMAC_GCFG_ARB_CFG_FIXED;
-  dmac_enable();
-#if USE_SAM3X_BUS_MATRIX_FIX
-  MATRIX->MATRIX_WPMR = 0x4d415400;
-  MATRIX->MATRIX_MCFG[1] = 1;
-  MATRIX->MATRIX_MCFG[2] = 1;
-  MATRIX->MATRIX_SCFG[0] = 0x01000010;
-  MATRIX->MATRIX_SCFG[1] = 0x01000010;
-  MATRIX->MATRIX_SCFG[7] = 0x01000010;
-#endif  // USE_SAM3X_BUS_MATRIX_FIX
-#endif  // USE_SAM3X_DMAC
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::deactivate() {
-  SPI.endTransaction();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::end() {
-  SPI.end();
-}
-//------------------------------------------------------------------------------
-static inline uint8_t spiTransfer(uint8_t b) {
-  Spi* pSpi = SPI0;
-
-  pSpi->SPI_TDR = b;
-  while ((pSpi->SPI_SR & SPI_SR_RDRF) == 0) {}
-  b = pSpi->SPI_RDR;
-  return b;
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive() {
-  return spiTransfer(0XFF);
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-  Spi* pSpi = SPI0;
-  int rtn = 0;
-#if USE_SAM3X_DMAC
-  // clear overrun error
-  while (pSpi->SPI_SR & (SPI_SR_OVRES | SPI_SR_RDRF)) {pSpi->SPI_RDR;}
-  spiDmaRX(buf, count);
-  spiDmaTX(0, count);
-
-  uint32_t m = millis();
-  while (!dmac_channel_transfer_done(SPI_DMAC_RX_CH)) {
-    if ((millis() - m) > SAM3X_DMA_TIMEOUT)  {
-      dmac_channel_disable(SPI_DMAC_RX_CH);
-      dmac_channel_disable(SPI_DMAC_TX_CH);
-      rtn = 2;
-      break;
-    }
-  }
-  if (pSpi->SPI_SR & SPI_SR_OVRES) {
-    rtn |= 1;
-  }
-#else  // USE_SAM3X_DMAC
-  for (size_t i = 0; i < count; i++) {
-    pSpi->SPI_TDR = 0XFF;
-    while ((pSpi->SPI_SR & SPI_SR_RDRF) == 0) {}
-    buf[i] = pSpi->SPI_RDR;
-  }
-#endif  // USE_SAM3X_DMAC
-  return rtn;
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(uint8_t data) {
-  spiTransfer(data);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(const uint8_t* buf , size_t count) {
-  Spi* pSpi = SPI0;
-#if USE_SAM3X_DMAC
-  spiDmaTX(buf, count);
-  while (!dmac_channel_transfer_done(SPI_DMAC_TX_CH)) {}
-#else  // #if USE_SAM3X_DMAC
-  while ((pSpi->SPI_SR & SPI_SR_TXEMPTY) == 0) {}
-  for (size_t i = 0; i < count; i++) {
-    pSpi->SPI_TDR = buf[i];
-    while ((pSpi->SPI_SR & SPI_SR_TDRE) == 0) {}
-  }
-#endif  // #if USE_SAM3X_DMAC
-  while ((pSpi->SPI_SR & SPI_SR_TXEMPTY) == 0) {}
-  // leave RDR empty
-  while (pSpi->SPI_SR & (SPI_SR_OVRES | SPI_SR_RDRF)) {pSpi->SPI_RDR;}
-}
-#endif  // defined(SD_USE_CUSTOM_SPI) && defined(ARDUINO_SAM_DUE)

lib/SdFat_NoArduino/src/SpiDriver/SdSpiESP.cpp

@@ -1,96 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include "SdSpiDriver.h"
-#if defined(SD_USE_CUSTOM_SPI) && (defined(ESP8266) || defined(ESP32))
-#define ESP_UNALIGN_OK 1
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::activate() {
-  m_spi->beginTransaction(m_spiSettings);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  if (spiConfig.spiPort) {
-    m_spi = spiConfig.spiPort;
-#if defined(SDCARD_SPI) && defined(SDCARD_SS_PIN)
-  } else if (spiConfig.csPin == SDCARD_SS_PIN) {
-    m_spi = &SDCARD_SPI;
-#endif  // defined(SDCARD_SPI) && defined(SDCARD_SS_PIN)
-  } else {
-    m_spi = &SPI;
-  }
-  m_spi->begin();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::deactivate() {
-  m_spi->endTransaction();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::end() {
-  m_spi->end();
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive() {
-  return m_spi->transfer(0XFF);
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-#if ESP_UNALIGN_OK
-  m_spi->transferBytes(nullptr, buf, count);
-#else  // ESP_UNALIGN_OK
-  // Adjust to 32-bit alignment.
-  while ((reinterpret_cast<uintptr_t>(buf) & 0X3) && count) {
-    *buf++ = m_spi->transfer(0xff);
-    count--;
-  }
-  // Do multiple of four byte transfers.
-  size_t n4 = 4*(count/4);
-  if (n4) {
-    m_spi->transferBytes(nullptr, buf, n4);
-  }
-  // Transfer up to three remaining bytes.
-  for (buf += n4, count -= n4; count; count--) {
-    *buf++ = m_spi->transfer(0xff);
-  }
-#endif  // ESP_UNALIGN_OK
-  return 0;
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(uint8_t data) {
-  m_spi->transfer(data);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(const uint8_t* buf , size_t count) {
-#if !ESP_UNALIGN_OK
-  // Adjust to 32-bit alignment.
-  while ((reinterpret_cast<uintptr_t>(buf) & 0X3) && count) {
-    SPI.transfer(*buf++);
-    count--;
-  }
-#endif  // #if ESP_UNALIGN_OK
-
-  m_spi->transferBytes(const_cast<uint8_t*>(buf), nullptr, count);
-}
-#endif  // defined(SD_USE_CUSTOM_SPI) && (defined(ESP8266) || defined(ESP32))

lib/SdFat_NoArduino/src/SpiDriver/SdSpiLibDriver.h

@@ -1,90 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief Class using only simple SPI library functions.
- */
-#ifndef SdSpiLibDriver_h
-#define SdSpiLibDriver_h
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::activate() {
-  m_spi->beginTransaction(m_spiSettings);
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  if (spiConfig.spiPort) {
-    m_spi = spiConfig.spiPort;
-#if defined(SDCARD_SPI) && defined(SDCARD_SS_PIN)
-  } else if (spiConfig.csPin == SDCARD_SS_PIN) {
-    m_spi = &SDCARD_SPI;
-#endif  // defined(SDCARD_SPI) && defined(SDCARD_SS_PIN)
-  } else {
-    m_spi = &SPI;
-  }
-  m_spi->begin();
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::end() {
-  m_spi->end();
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::deactivate() {
-  m_spi->endTransaction();
-}
-//------------------------------------------------------------------------------
-inline uint8_t SdSpiArduinoDriver::receive() {
-  return m_spi->transfer( 0XFF);
-}
-//------------------------------------------------------------------------------
-inline uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-#if USE_SPI_ARRAY_TRANSFER
-  memset(buf, 0XFF, count);
-  m_spi->transfer(buf, count);
-#else  // USE_SPI_ARRAY_TRANSFER
-  for (size_t i = 0; i < count; i++) {
-    buf[i] = m_spi->transfer(0XFF);
-  }
-#endif  // USE_SPI_ARRAY_TRANSFER
-  return 0;
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::send(uint8_t data) {
-  m_spi->transfer(data);
-}
-//------------------------------------------------------------------------------
-inline void SdSpiArduinoDriver::send(const uint8_t* buf, size_t count) {
-#if USE_SPI_ARRAY_TRANSFER
-  if (count <= 512) {
-    uint8_t tmp[512];
-    memcpy(tmp, buf, count);
-    m_spi->transfer(tmp, count);
-  }
-#else  // USE_SPI_ARRAY_TRANSFER
-  for (size_t i = 0; i < count; i++) {
-    m_spi->transfer(buf[i]);
-  }
-#endif  // USE_SPI_ARRAY_TRANSFER
-}
-#endif  // SdSpiLibDriver_h

lib/SdFat_NoArduino/src/SpiDriver/SdSpiParticle.cpp

@@ -1,78 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "SdSpiDriver.h"
-#if defined(SD_USE_CUSTOM_SPI) && defined(PLATFORM_ID)
-static volatile bool SPI_DMA_TransferCompleted = false;
-//-----------------------------------------------------------------------------
-static void SD_SPI_DMA_TransferComplete_Callback() {
-  SPI_DMA_TransferCompleted = true;
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::activate() {
-  m_spi->beginTransaction(m_spiSettings);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  if (spiConfig.spiPort) {
-    m_spi = spiConfig.spiPort;
-  } else {
-    m_spi = &SPI;
-  }
-  m_spi->begin();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::deactivate() {
-  m_spi->endTransaction();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::end() {
-  m_spi->end();
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive() {
-  return m_spi->transfer(0XFF);
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-  SPI_DMA_TransferCompleted = false;
-  m_spi->transfer(nullptr, buf, count, SD_SPI_DMA_TransferComplete_Callback);
-  while (!SPI_DMA_TransferCompleted) {}
-  return 0;
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(uint8_t data) {
-  m_spi->transfer(data);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(const uint8_t* buf , size_t count) {
-  SPI_DMA_TransferCompleted = false;
-
-  m_spi->transfer(const_cast<uint8_t*>(buf), nullptr, count,
-                            SD_SPI_DMA_TransferComplete_Callback);
-
-  while (!SPI_DMA_TransferCompleted) {}
-}
-#endif  // defined(SD_USE_CUSTOM_SPI) && defined(PLATFORM_ID)
-

lib/SdFat_NoArduino/src/SpiDriver/SdSpiSTM32.cpp

@@ -1,82 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-// Driver for: https://github.com/rogerclarkmelbourne/Arduino_STM32
-#include "SdSpiDriver.h"
-#if defined(SD_USE_CUSTOM_SPI)\
-  && (defined(__STM32F1__) || defined(__STM32F4__))
-#if defined(__STM32F1__)
-#define USE_STM32_DMA 1
-#elif defined(__STM32F4__)
-#define USE_STM32_DMA 1
-#else  // defined(__STM32F1__)
-#error Unknown STM32 type
-#endif  // defined(__STM32F1__)
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::activate() {
-  m_spi->beginTransaction(m_spiSettings);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  if (spiConfig.spiPort) {
-    m_spi = spiConfig.spiPort;
-  } else {
-    m_spi = &SPI;
-  }
-  m_spi->begin();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::deactivate() {
-  m_spi->endTransaction();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::end() {
-  m_spi->end();
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive() {
-  return m_spi->transfer(0XFF);
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-#if USE_STM32_DMA
-  return m_spi->dmaTransfer(nullptr, buf, count);
-#else  // USE_STM32_DMA
-  m_spi->read(buf, count);
-  return 0;
-#endif  // USE_STM32_DMA
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(uint8_t data) {
-  m_spi->transfer(data);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(const uint8_t* buf , size_t count) {
-#if USE_STM32_DMA
-  m_spi->dmaTransfer(const_cast<uint8*>(buf), nullptr, count);
-#else  // USE_STM32_DMA
-  m_spi->write(const_cast<uint8*>(buf), count);
-#endif  // USE_STM32_DMA
-}
-#endif  // defined(SD_USE_CUSTOM_SPI) &&  defined(__STM32F1__)

lib/SdFat_NoArduino/src/SpiDriver/SdSpiSTM32Core.cpp

@@ -1,75 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-// Driver for: https://github.com/stm32duino/Arduino_Core_STM32
-#include "SdSpiDriver.h"
-#if defined(SD_USE_CUSTOM_SPI) && defined(STM32_CORE_VERSION)
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::activate() {
-  m_spi->beginTransaction(m_spiSettings);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  if (spiConfig.spiPort) {
-    m_spi = spiConfig.spiPort;
-  } else {
-    m_spi = &SPI;
-  }
-  m_spi->begin();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::deactivate() {
-  m_spi->endTransaction();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::end() {
-  m_spi->end();
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive() {
-  return m_spi->transfer(0XFF);
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-  // Must send 0XFF - SD looks at send data for command.
-  memset(buf, 0XFF, count);
-  m_spi->transfer(buf, count);
-  return 0;
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(uint8_t data) {
-  m_spi->transfer(data);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(const uint8_t* buf, size_t count) {
-  // Avoid stack overflow if bad count.  This should cause a write error.
-  if (count > 512) {
-    return;
-  }
-  // Not easy to avoid receive so use tmp RX buffer.
-  uint8_t rxBuf[512];
-  // Discard const - STM32 not const correct.
-  m_spi->transfer(const_cast<uint8_t*>(buf), rxBuf, count);
-}
-#endif  // defined(SD_USE_CUSTOM_SPI) && defined(STM32_CORE_VERSION)

lib/SdFat_NoArduino/src/SpiDriver/SdSpiSoftDriver.h

@@ -1,121 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief Class for software SPI.
- */
-#ifndef SdSpiSoftDriver_h
-#define SdSpiSoftDriver_h
-#include "../DigitalIO/SoftSPI.h"
-/**
- * \class SdSpiSoftDriver
- * \brief Base class for external soft SPI.
- */
-class SdSpiSoftDriver {
- public:
-  /** Activate SPI hardware. */
-  void activate() {}
-  /** Initialize the SPI bus. */
-  virtual void begin() = 0;
-  /** Initialize the SPI bus.
-   *
-   * \param[in] spiConfig SD card configuration.
-   */
-  void begin(SdSpiConfig spiConfig) {
-    (void)spiConfig;
-    begin();
-  }
-  /** Deactivate SPI hardware. */
-  void deactivate() {}
-  /** deactivate SPI driver. */
-  void end() {}
-  /** Receive a byte.
-   *
-   * \return The byte.
-   */
-  virtual uint8_t receive() = 0;
-  /** Receive multiple bytes.
-   *
-   * \param[out] buf Buffer to receive the data.
-   * \param[in] count Number of bytes to receive.
-   *
-   * \return Zero for no error or nonzero error code.
-   */
-  uint8_t receive(uint8_t* buf, size_t count) {
-    for (size_t i = 0; i < count; i++) {
-      buf[i] = receive();
-    }
-    return 0;
-  }
-  /** Send a byte.
-   *
-   * \param[in] data Byte to send
-   */
-  virtual void send(uint8_t data) = 0;
-  /** Send multiple bytes.
-   *
-   * \param[in] buf Buffer for data to be sent.
-   * \param[in] count Number of bytes to send.
-   */
-  void send(const uint8_t* buf, size_t count) {
-    for (size_t i = 0; i < count; i++) {
-      send(buf[i]);
-    }
-  }
-  /** Save high speed SPISettings after SD initialization.
-   *
-   * \param[in] maxSck Maximum SCK frequency.
-   */
-  void setSckSpeed(uint32_t maxSck) {
-    (void)maxSck;
-  }
-};
-//------------------------------------------------------------------------------
-/**
- * \class SoftSpiDriver
- * \brief Class for external soft SPI.
- */
-template<uint8_t MisoPin, uint8_t MosiPin, uint8_t SckPin>
-class SoftSpiDriver : public SdSpiSoftDriver {
- public:
-  /** Initialize the SPI bus. */
-  void begin() {m_spi.begin();}
-  /** Receive a byte.
-   *
-   * \return The byte.
-   */
-  uint8_t receive() {return m_spi.receive();}
-  /** Send a byte.
-   *
-   * \param[in] data Byte to send
-   */
-  void send(uint8_t data) {m_spi.send(data);}
- private:
-  SoftSPI<MisoPin, MosiPin, SckPin, 0> m_spi;
-};
-
-/** Typedef for use of SdSoftSpiDriver */
-typedef SdSpiSoftDriver SdSpiDriver;
-#endif  // SdSpiSoftDriver_h

lib/SdFat_NoArduino/src/SpiDriver/SdSpiTeensy3.cpp

@@ -1,90 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "SdSpiDriver.h"
-#if defined(SD_USE_CUSTOM_SPI) &&  defined(__arm__) && defined(CORE_TEENSY)
-#define USE_BLOCK_TRANSFER 1
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::activate() {
-  m_spi->beginTransaction(m_spiSettings);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::begin(SdSpiConfig spiConfig) {
-  if (spiConfig.spiPort) {
-    m_spi = spiConfig.spiPort;
-#if defined(SDCARD_SPI) && defined(SDCARD_SS_PIN)
-  } else if (spiConfig.csPin == SDCARD_SS_PIN) {
-    m_spi = &SDCARD_SPI;
-    m_spi->setMISO(SDCARD_MISO_PIN);
-    m_spi->setMOSI(SDCARD_MOSI_PIN);
-    m_spi->setSCK(SDCARD_SCK_PIN);
-#endif  // defined(SDCARD_SPI) && defined(SDCARD_SS_PIN)
-  } else {
-    m_spi = &SPI;
-  }
-  m_spi->begin();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::deactivate() {
-  m_spi->endTransaction();
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::end() {
-  m_spi->end();
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive() {
-  return m_spi->transfer(0XFF);
-}
-//------------------------------------------------------------------------------
-uint8_t SdSpiArduinoDriver::receive(uint8_t* buf, size_t count) {
-#if USE_BLOCK_TRANSFER
-  memset(buf, 0XFF, count);
-  m_spi->transfer(buf, count);
-#else  // USE_BLOCK_TRANSFER
-  for (size_t i = 0; i < count; i++) {
-    buf[i] = m_spi->transfer(0XFF);
-  }
-#endif  // USE_BLOCK_TRANSFER
-  return 0;
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(uint8_t data) {
-  m_spi->transfer(data);
-}
-//------------------------------------------------------------------------------
-void SdSpiArduinoDriver::send(const uint8_t* buf , size_t count) {
-#if USE_BLOCK_TRANSFER
-  uint32_t tmp[128];
-  if (0 < count && count <= 512) {
-    memcpy(tmp, buf, count);
-    m_spi->transfer(tmp, count);
-    return;
-  }
-#endif  // USE_BLOCK_TRANSFER
-  for (size_t i = 0; i < count; i++) {
-    m_spi->transfer(buf[i]);
-  }
-}
-#endif  // defined(SD_USE_CUSTOM_SPI) && defined(__arm__) &&defined(CORE_TEENSY)

lib/SdFat_NoArduino/src/common/ArduinoFiles.h

@@ -1,159 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef ArduinoFiles_h
-#define ArduinoFiles_h
-#include "SysCall.h"
-//------------------------------------------------------------------------------
-/** Arduino SD.h style flag for open for read. */
-#ifndef FILE_READ
-#define FILE_READ O_RDONLY
-#endif  // FILE_READ
-/** Arduino SD.h style flag for open at EOF for read/write with create. */
-#ifndef FILE_WRITE
-#define FILE_WRITE (O_RDWR | O_CREAT | O_AT_END)
-#endif  // FILE_WRITE
-//------------------------------------------------------------------------------
-/**
- * \class PrintFile
- * \brief PrintFile class.
- */
-template<class BaseFile>
-class PrintFile : public print_t, public BaseFile {
- public:
-  using BaseFile::clearWriteError;
-  using BaseFile::getWriteError;
-  using BaseFile::read;
-  using BaseFile::write;
-  /** Write a single byte.
-   * \param[in] b byte to write.
-   * \return one for success.
-   */
-  size_t write(uint8_t b) {
-    return BaseFile::write(&b, 1);
-  }
-};
-//------------------------------------------------------------------------------
-/**
- * \class StreamFile
- * \brief StreamFile class.
- */
-template<class BaseFile, typename PosType>
-class StreamFile : public stream_t, public BaseFile {
- public:
-  using BaseFile::clearWriteError;
-  using BaseFile::getWriteError;
-  using BaseFile::read;
-  using BaseFile::write;
-
-  StreamFile() {}
-
-  /** \return number of bytes available from the current position to EOF
-   *   or INT_MAX if more than INT_MAX bytes are available.
-   */
-  int available() {
-    return BaseFile::available();
-  }
-  /** Ensure that any bytes written to the file are saved to the SD card. */
-  void flush() {
-    BaseFile::sync();
-  }
-  /** This function reports if the current file is a directory or not.
-  * \return true if the file is a directory.
-  */
-  bool isDirectory() {
-    return BaseFile::isDir();
-  }
-  /** No longer implemented due to Long File Names.
-   *
-   * Use getName(char* name, size_t size).
-   * \return a pointer to replacement suggestion.
-   */
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  char* __attribute__((error("use getName(name, size)"))) name();
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-  /** Return the next available byte without consuming it.
-   *
-   * \return The byte if no error and not at eof else -1;
-   */
-  int peek() {
-    return BaseFile::peek();
-  }
-  /** \return the current file position. */
-  PosType position() {
-    return BaseFile::curPosition();
-  }
-  /** Read the next byte from a file.
-   *
-   * \return For success return the next byte in the file as an int.
-   * If an error occurs or end of file is reached return -1.
-   */
-  int read() {
-    return BaseFile::read();
-  }
-  /** Rewind a file if it is a directory */
-  void rewindDirectory() {
-    if (BaseFile::isDir()) {
-      BaseFile::rewind();
-    }
-  }
-  /**
-   * Seek to a new position in the file, which must be between
-   * 0 and the size of the file (inclusive).
-   *
-   * \param[in] pos the new file position.
-   * \return true for success or false for failure.
-   */
-  bool seek(PosType pos) {
-    return BaseFile::seekSet(pos);
-  }
-  /** \return the file's size. */
-  PosType size() {
-    return BaseFile::fileSize();
-  }
-  /** Write a byte to a file. Required by the Arduino Print class.
-   * \param[in] b the byte to be written.
-   * Use getWriteError to check for errors.
-   * \return 1 for success and 0 for failure.
-   */
-  size_t write(uint8_t b) {
-    return BaseFile::write(b);
-  }
-  /** Write data to an open file.
-   *
-   * \note Data is moved to the cache but may not be written to the
-   * storage device until sync() is called.
-   *
-   * \param[in] buffer Pointer to the location of the data to be written.
-   *
-   * \param[in] size Number of bytes to write.
-   *
-   * \return For success write() returns the number of bytes written, always
-   * \a size.
-   */
-  size_t write(const uint8_t* buffer, size_t size) {
-    return BaseFile::write(buffer, size);
-  }
-};
-#endif  // ArduinoFiles_h

lib/SdFat_NoArduino/src/common/CompileDateTime.h

@@ -1,74 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef CompileDateTime_h
-#define CompileDateTime_h
-// Note - these functions will compile to a few bytes
-//        since they are evaluated at compile time.
-
-/** \return year field of the __DATE__ macro. */
-constexpr uint16_t compileYear() {
-  return  1000*(__DATE__[7] - '0')
-         + 100*(__DATE__[8] - '0')
-          + 10*(__DATE__[9] - '0')
-             + (__DATE__[10] - '0');
-}
-/** \return true if str equals the month field of the __DATE__ macro. */
-constexpr bool compileMonthIs(const char* str) {
-  return __DATE__[0] == str[0]
-      && __DATE__[1] == str[1]
-      && __DATE__[2] == str[2];
-}
-/** \return month field of the __DATE__ macro. */
-constexpr uint8_t compileMonth() {
-  return compileMonthIs("Jan") ? 1 :
-         compileMonthIs("Feb") ? 2 :
-         compileMonthIs("Mar") ? 3 :
-         compileMonthIs("Apr") ? 4 :
-         compileMonthIs("May") ? 5 :
-         compileMonthIs("Jun") ? 6 :
-         compileMonthIs("Jul") ? 7 :
-         compileMonthIs("Aug") ? 8 :
-         compileMonthIs("Sep") ? 9 :
-         compileMonthIs("Oct") ? 10 :
-         compileMonthIs("Nov") ? 11 :
-         compileMonthIs("Dec") ? 12 : 0;
-}
-/** \return day field of the __DATE__ macro. */
-constexpr uint8_t compileDay() {
-  return 10*(__DATE__[4] == ' ' ? 0 : __DATE__[4] - '0') + (__DATE__[5] - '0');
-}
-/** \return hour field of the __TIME__ macro. */
-constexpr uint8_t compileHour() {
-  return 10*(__TIME__[0] - '0') + __TIME__[1] - '0';
-}
-/** \return minute field of the __TIME__ macro. */
-constexpr uint8_t compileMinute() {
-  return 10*(__TIME__[3] - '0') + __TIME__[4] - '0';
-}
-/** \return second field of the __TIME__ macro. */
-constexpr uint8_t compileSecond() {
-  return 10*(__TIME__[6] - '0') + __TIME__[7] - '0';
-}
-#endif  // CompileDateTime_h

lib/SdFat_NoArduino/src/common/DebugMacros.h

@@ -1,74 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef DebugMacros_h
-#define DebugMacros_h
-#include "SysCall.h"
-
-// 0 - disable, 1 - fail, halt 2 - fail, halt, warn
-#define USE_DBG_MACROS 0
-
-#if USE_DBG_MACROS
-#include "Arduino.h"
-#ifndef DBG_FILE
-#error DBG_FILE not defined
-#endif  // DBG_FILE
-
-__attribute__((unused)) static void dbgFail(uint16_t line) {
-  Serial.print(F("DBG_FAIL: "));
-  Serial.print(F(DBG_FILE));
-  Serial.write('.');
-  Serial.println(line);
-}
-__attribute__((unused)) static void dbgHalt(uint16_t line) {
-  Serial.print(F("DBG_HALT: "));
-  Serial.print(F(DBG_FILE));
-  Serial.write('.');
-  Serial.println(line);
-  while (true) {}
-}
-#define DBG_FAIL_MACRO dbgFail(__LINE__)
-#define DBG_HALT_MACRO dbgHalt(__LINE__)
-#define DBG_HALT_IF(b) if (b) {dbgHalt(__LINE__);}
-
-#else  // USE_DBG_MACROS
-#define DBG_FAIL_MACRO
-#define DBG_HALT_MACRO
-#define DBG_HALT_IF(b)
-#endif  // USE_DBG_MACROS
-
-#if USE_DBG_MACROS > 1
-__attribute__((unused)) static void dbgWarn(uint16_t line) {
-  Serial.print(F("DBG_WARN: "));
-  Serial.print(F(DBG_FILE));
-  Serial.write('.');
-  Serial.println(line);
-}
-#define DBG_WARN_MACRO dbgWarn(__LINE__)
-#define DBG_WARN_IF(b) if (b) {dbgWarn(__LINE__);}
-#else  // USE_DBG_MACROS > 1
-#define DBG_WARN_MACRO
-#define DBG_WARN_IF(b)
-#endif  // USE_DBG_MACROS > 1
-#endif  // DebugMacros_h

lib/SdFat_NoArduino/src/common/FmtNumber.cpp

@@ -1,515 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FmtNumber.h"
-// always use fmtBase10() - seems fast even on teensy 3.6.
-#define USE_FMT_BASE10 1
-
-// Use Stimmer div/mod 10 on avr
-#ifdef __AVR__
-#include <avr/pgmspace.h>
-#define USE_STIMMER
-#endif  // __AVR__
-//------------------------------------------------------------------------------
-// Stimmer div/mod 10 for AVR
-// this code fragment works out i/10 and i%10 by calculating
-// i*(51/256)*(256/255)/2 == i*51/510 == i/10
-// by "j.k" I mean 32.8 fixed point, j is integer part, k is fractional part
-// j.k = ((j+1.0)*51.0)/256.0
-// (we add 1 because we will be using the floor of the result later)
-// divmod10_asm16 and divmod10_asm32 are public domain code by Stimmer.
-// http://forum.arduino.cc/index.php?topic=167414.msg1293679#msg1293679
-#define divmod10_asm16(in32, mod8, tmp8)    \
-asm volatile(          \
-      " ldi %2,51     \n\t"     \
-      " mul %A0,%2    \n\t"     \
-      " clr %A0       \n\t"     \
-      " add r0,%2     \n\t"     \
-      " adc %A0,r1    \n\t"     \
-      " mov %1,r0     \n\t"     \
-      " mul %B0,%2    \n\t"     \
-      " clr %B0       \n\t"     \
-      " add %A0,r0    \n\t"     \
-      " adc %B0,r1    \n\t"     \
-      " clr r1        \n\t"     \
-      " add %1,%A0    \n\t"     \
-      " adc %A0,%B0   \n\t"     \
-      " adc %B0,r1   \n\t"      \
-      " add %1,%B0    \n\t"     \
-      " adc %A0,r1   \n\t"      \
-      " adc %B0,r1    \n\t"     \
-      " lsr %B0       \n\t"     \
-      " ror %A0       \n\t"     \
-      " ror %1        \n\t"     \
-      " ldi %2,10     \n\t"     \
-      " mul %1,%2     \n\t"     \
-      " mov %1,r1     \n\t"     \
-      " clr r1        \n\t"     \
-      :"+r"(in32), "=d"(mod8), "=d"(tmp8) : : "r0")
-
-#define divmod10_asm32(in32, mod8, tmp8)    \
-asm volatile(          \
-      " ldi %2,51     \n\t"     \
-      " mul %A0,%2    \n\t"     \
-      " clr %A0       \n\t"     \
-      " add r0,%2     \n\t"     \
-      " adc %A0,r1    \n\t"     \
-      " mov %1,r0     \n\t"     \
-      " mul %B0,%2    \n\t"     \
-      " clr %B0       \n\t"     \
-      " add %A0,r0    \n\t"     \
-      " adc %B0,r1    \n\t"     \
-      " mul %C0,%2    \n\t"     \
-      " clr %C0       \n\t"     \
-      " add %B0,r0    \n\t"     \
-      " adc %C0,r1    \n\t"     \
-      " mul %D0,%2    \n\t"     \
-      " clr %D0       \n\t"     \
-      " add %C0,r0    \n\t"     \
-      " adc %D0,r1    \n\t"     \
-      " clr r1        \n\t"     \
-      " add %1,%A0    \n\t"     \
-      " adc %A0,%B0   \n\t"     \
-      " adc %B0,%C0   \n\t"     \
-      " adc %C0,%D0   \n\t"     \
-      " adc %D0,r1    \n\t"     \
-      " add %1,%B0    \n\t"     \
-      " adc %A0,%C0   \n\t"     \
-      " adc %B0,%D0   \n\t"     \
-      " adc %C0,r1    \n\t"     \
-      " adc %D0,r1    \n\t"     \
-      " add %1,%D0    \n\t"     \
-      " adc %A0,r1    \n\t"     \
-      " adc %B0,r1    \n\t"     \
-      " adc %C0,r1    \n\t"     \
-      " adc %D0,r1    \n\t"     \
-      " lsr %D0       \n\t"     \
-      " ror %C0       \n\t"     \
-      " ror %B0       \n\t"     \
-      " ror %A0       \n\t"     \
-      " ror %1        \n\t"     \
-      " ldi %2,10     \n\t"     \
-      " mul %1,%2     \n\t"     \
-      " mov %1,r1     \n\t"     \
-      " clr r1        \n\t"     \
-      :"+r"(in32), "=d"(mod8), "=d"(tmp8) : : "r0")
-//------------------------------------------------------------------------------
-/*
-// C++ code is based on this version of divmod10 by robtillaart.
-// http://forum.arduino.cc/index.php?topic=167414.msg1246851#msg1246851
-// from robtillaart post:
-// The code is based upon the divu10() code from the book Hackers Delight1.
-// My insight was that the error formula in divu10() was in fact modulo 10
-// but not always. Sometimes it was 10 more.
-void divmod10(uint32_t in, uint32_t &div, uint32_t &mod)
-{
-  // q = in * 0.8;
-  uint32_t q = (in >> 1) + (in >> 2);
-  q = q + (q >> 4);
-  q = q + (q >> 8);
-  q = q + (q >> 16);  // not needed for 16 bit version
-
-  // q = q / 8;  ==> q =  in *0.1;
-  q = q >> 3;
-
-  // determine error
-  uint32_t r = in - ((q << 3) + (q << 1));   // r = in - q*10;
-  div = q + (r > 9);
-  if (r > 9) mod = r - 10;
-  else mod = r;
-}
-// See: https://github.com/hcs0/Hackers-Delight
-// Code below uses 8/10 = 0.1100 1100 1100 1100 1100 1100 1100 1100.
-// 15 ops including the multiply, or 17 elementary ops.
-unsigned divu10(unsigned n) {
-   unsigned q, r;
-
-   q = (n >> 1) + (n >> 2);
-   q = q + (q >> 4);
-   q = q + (q >> 8);
-   q = q + (q >> 16);
-   q = q >> 3;
-   r = n - q*10;
-   return q + ((r + 6) >> 4);
-// return q + (r > 9);
-}
-*/
-//------------------------------------------------------------------------------
-// Format 16-bit unsigned
-char* fmtBase10(char* str, uint16_t n) {
-  while (n > 9) {
-#ifdef USE_STIMMER
-    uint8_t tmp8, r;
-    divmod10_asm16(n, r, tmp8);
-#else  // USE_STIMMER
-    uint16_t t = n;
-    n = (n >> 1) + (n >> 2);
-    n = n + (n >> 4);
-    n = n + (n >> 8);
-    // n = n + (n >> 16);  // no code for 16-bit n
-    n = n >> 3;
-    uint8_t r = t - (((n << 2) + n) << 1);
-    if (r > 9) {
-      n++;
-      r -= 10;
-    }
-#endif  // USE_STIMMER
-    *--str = r + '0';
-  }
-  *--str = n + '0';
-  return str;
-}
-//------------------------------------------------------------------------------
-// format 32-bit unsigned
-char* fmtBase10(char* str, uint32_t n) {
-  while (n > 0XFFFF) {
-#ifdef USE_STIMMER
-    uint8_t tmp8, r;
-    divmod10_asm32(n, r, tmp8);
-#else  //  USE_STIMMER
-    uint32_t t = n;
-    n = (n >> 1) + (n >> 2);
-    n = n + (n >> 4);
-    n = n + (n >> 8);
-    n = n + (n >> 16);
-    n = n >> 3;
-    uint8_t r = t - (((n << 2) + n) << 1);
-    if (r > 9) {
-      n++;
-      r -= 10;
-    }
-#endif  // USE_STIMMER
-    *--str = r + '0';
-  }
-  return fmtBase10(str, (uint16_t)n);
-}
-//------------------------------------------------------------------------------
-char* fmtHex(char* str, uint32_t n) {
-  do {
-    uint8_t h = n & 0XF;
-    *--str = h + (h < 10 ? '0' : 'A' - 10);
-    n >>= 4;
-  } while (n);
-  return str;
-}
-//------------------------------------------------------------------------------
-char* fmtSigned(char* str, int32_t num, uint8_t base, bool caps) {
-  bool neg = base == 10 && num < 0;
-  if (neg) {
-    num = -num;
-  }
-  str = fmtUnsigned(str, num, base, caps);
-  if (neg) {
-    *--str = '-';
-  }
-  return str;
-}
-//-----------------------------------------------------------------------------
-char* fmtUnsigned(char* str, uint32_t num, uint8_t base, bool caps) {
-#if USE_FMT_BASE10
-  if (base == 10) return fmtBase10(str, (uint32_t)num);
-#endif  // USE_FMT_BASE10
-  do {
-    int c = num%base;
-    *--str = c + (c < 10 ? '0' : caps ? 'A' - 10 : 'a' - 10);
-  } while (num /= base);
-  return str;
-}
-//-----------------------------------------------------------------------------
-
-static const double powTen[] = {1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9};
-static const double rnd[] =
-  {5e-1, 5e-2, 5e-3, 5e-4, 5e-5, 5e-6, 5e-7, 5e-8, 5e-9, 5e-10};
-static const size_t MAX_PREC = sizeof(powTen)/sizeof(powTen[0]);
-
-char *fmtDouble(char *str, double num, uint8_t prec, bool altFmt) {
-  bool neg = num < 0;
-  if (neg) {
-    num = -num;
-  }
-  if (isnan(num)) {
-    *--str = 'n';
-    *--str = 'a';
-    *--str = 'n';
-    return str;
-  }
-  if (isinf(num)) {
-    *--str = 'f';
-    *--str = 'n';
-    *--str = 'i';
-    return str;
-  }
-  // last float < 2^32
-  if (num > 4294967040.0) {
-    *--str = 'f';
-    *--str = 'v';
-    *--str = 'o';
-    return str;
-  }
-
-  if (prec > MAX_PREC) {
-    prec = MAX_PREC;
-  }
-  num += rnd[prec];
-  uint32_t ul = num;
-  if (prec) {
-    char* s = str - prec;
-    uint32_t f = (num - ul)*powTen[prec - 1];
-    str = fmtBase10(str, f);
-    while (str > s) {
-      *--str = '0';
-    }
-  }
-  if (prec || altFmt) {
-    *--str = '.';
-  }
-  str = fmtBase10(str, ul);
-  if (neg) {
-    *--str = '-';
-  }
-  return str;
-}
-//------------------------------------------------------------------------------
-/** Print a number followed by a field terminator.
- * \param[in] value The number to be printed.
- * \param[in] ptr Pointer to last char in buffer.
- * \param[in] prec Number of digits after decimal point.
- * \param[in] expChar Use exp format if non zero.
- * \return Pointer to first character of result.
- */
-char* fmtDouble(char* str, double value,
-                uint8_t prec, bool altFmt, char expChar) {
-  if (expChar != 'e' && expChar != 'E') {
-    expChar = 0;
-  }
-  bool neg = value < 0;
-  if (neg) {
-    value = -value;
-  }
-  // check for nan inf ovf
-  if (isnan(value)) {
-    *--str = 'n';
-    *--str = 'a';
-    *--str = 'n';
-    return str;
-  }
-  if (isinf(value)) {
-    *--str = 'f';
-    *--str = 'n';
-    *--str = 'i';
-    return str;
-  }
-  if (!expChar && value > 4294967040.0) {
-    *--str = 'f';
-    *--str = 'v';
-    *--str = 'o';
-    return str;
-  }
-  if (prec > 9) {
-    prec = 9;
-  }
-  if (expChar) {
-    int8_t exp = 0;
-    bool expNeg = false;
-    if (value) {
-      if (value > 10.0L) {
-        while (value > 1e16L) {
-          value *= 1e-16L;
-          exp += 16;
-        }
-        while (value > 1e4L) {
-          value *= 1e-4L;
-          exp += 4;
-        }
-        while (value > 10.0L) {
-          value *= 0.1L;
-          exp++;
-        }
-      } else if (value < 1.0L) {
-         while (value < 1e-16L) {
-          value *= 1e16L;
-          exp -= 16;
-        }
-         while (value < 1e-4L) {
-          value *= 1e4L;
-          exp -= 4;
-        }
-        while (value < 1.0L) {
-          value *= 10.0L;
-          exp--;
-        }
-      }
-      value += rnd[prec];
-      if (value >= 10.0L) {
-        value *= 0.1L;
-        exp++;
-      }
-      expNeg = exp < 0;
-      if (expNeg) {
-        exp = -exp;
-      }
-    }
-    str = fmtBase10(str, (uint16_t)exp);
-    if (exp < 10) {
-      *--str = '0';
-    }
-    *--str = expNeg ? '-' : '+';
-    *--str = expChar;
-  } else {
-    // round value
-    value += rnd[prec];
-  }
-
-  uint32_t whole = value;
-  if (prec) {
-    char* tmp = str - prec;
-    uint32_t fraction = (value - whole)*powTen[prec - 1];
-    str = fmtBase10(str, fraction);
-    while (str > tmp) {
-      *--str = '0';
-    }
-  }
-  if (prec || altFmt)*--str = '.';
-  str = fmtBase10(str, whole);
-  if (neg) {
-    *--str = '-';
-  }
-  return str;
-}
-//==============================================================================
-//  functions below not used
-//------------------------------------------------------------------------------
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-#ifdef __AVR__
-static const float m[] PROGMEM = {1e-1, 1e-2, 1e-4, 1e-8, 1e-16, 1e-32};
-static const float p[] PROGMEM = {1e+1, 1e+2, 1e+4, 1e+8, 1e+16, 1e+32};
-#else  // __AVR__
-static const float m[] = {1e-1, 1e-2, 1e-4, 1e-8, 1e-16, 1e-32};
-static const float p[] = {1e+1, 1e+2, 1e+4, 1e+8, 1e+16, 1e+32};
-#endif  // __AVR__
-#endif  // DOXYGEN_SHOULD_SKIP_THIS
-// scale float v by power of ten. return v*10^n
-float scale10(float v, int8_t n) {
-  const float *s;
-  if (n < 0) {
-    n = -n;
-    s = m;
-  } else {
-    s = p;
-  }
-  n &= 63;
-  for (uint8_t i = 0; n; n >>= 1, i++) {
-#ifdef __AVR__
-    if (n & 1) {
-      v *= pgm_read_float(&s[i]);
-    }
-#else  // __AVR__
-    if (n & 1) {
-      v *= s[i];
-    }
-#endif  // __AVR__
-  }
-  return v;
-}
-//------------------------------------------------------------------------------
-float scanFloat(const char* str, const char** ptr) {
-  int16_t const EXP_LIMIT = 100;
-  bool digit = false;
-  bool dot = false;
-  uint32_t fract = 0;
-  int fracExp = 0;
-  uint8_t nd = 0;
-  bool neg;
-  int c;
-  float v;
-  const char* successPtr = str;
-
-  if (ptr) {
-    *ptr = str;
-  }
-
-  while (isSpace((c = *str++))) {}
-  neg = c == '-';
-  if (c == '-' || c == '+') {
-    c = *str++;
-  }
-  // Skip leading zeros
-  while (c == '0') {
-    c = *str++;
-    digit = true;
-  }
-  for (;;) {
-    if (isDigit(c)) {
-      digit = true;
-      if (nd < 9) {
-        fract = 10*fract + c - '0';
-        nd++;
-        if (dot) {
-          fracExp--;
-        }
-      } else {
-        if (!dot) {
-          fracExp++;
-        }
-      }
-    } else if (c == '.') {
-      if (dot) {
-        goto fail;
-      }
-      dot = true;
-    } else {
-      if (!digit) {
-        goto fail;
-      }
-      break;
-    }
-    successPtr = str;
-    c = *str++;
-  }
-  if (c == 'e' || c == 'E') {
-    int exp = 0;
-    c = *str++;
-    bool expNeg = c == '-';
-    if (c == '-' || c == '+') {
-      c = *str++;
-    }
-    while (isDigit(c)) {
-      if (exp > EXP_LIMIT) {
-        goto fail;
-      }
-      exp = 10*exp + c - '0';
-      successPtr = str;
-      c = *str++;
-    }
-    fracExp += expNeg ? -exp : exp;
-  }
-  if (ptr) {
-    *ptr = successPtr;
-  }
-  v = scale10(static_cast<float>(fract), fracExp);
-  return neg ? -v : v;
-
- fail:
-  return 0;
-}

lib/SdFat_NoArduino/src/common/FmtNumber.h

@@ -1,43 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FmtNumber_h
-#define FmtNumber_h
-#include <math.h>
-#include <stdint.h>
-#include <stddef.h>
-inline bool isDigit(char c) {
-  return '0' <= (c) && (c) <= '9';
-}
-inline bool isSpace(char c) {
-  return (c) == ' ' || (0X9 <= (c) && (c) <= 0XD);
-}
-char* fmtBase10(char* str, uint16_t n);
-char* fmtBase10(char* str, uint32_t n);
-char* fmtDouble(char *str, double d, uint8_t prec, bool altFmt);
-char* fmtDouble(char* str, double d, uint8_t prec, bool altFmt, char expChar);
-char* fmtHex(char* str, uint32_t n);
-char* fmtSigned(char* str, int32_t n, uint8_t base, bool caps);
-char* fmtUnsigned(char* str, uint32_t n, uint8_t base, bool caps);
-#endif  // FmtNumber_h

lib/SdFat_NoArduino/src/common/FsApiConstants.h

@@ -1,85 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsApiConstants_h
-#define FsApiConstants_h
-#include "SysCall.h"
-#if USE_FCNTL_H
-#include <fcntl.h>
-/* values for GNU Arm Embedded Toolchain.
- * O_RDONLY:   0x0
- * O_WRONLY:   0x1
- * O_RDWR:     0x2
- * O_ACCMODE:  0x3
- * O_APPEND:   0x8
- * O_CREAT:    0x200
- * O_TRUNC:    0x400
- * O_EXCL:     0x800
- * O_SYNC:     0x2000
- * O_NONBLOCK: 0x4000
- */
-/** Use O_NONBLOCK for open at EOF */
-#define O_AT_END O_NONBLOCK  ///< Open at EOF.
-typedef int oflag_t;
-#else  // USE_FCNTL_H
-#define O_RDONLY  0X00  ///< Open for reading only.
-#define O_WRONLY  0X01  ///< Open for writing only.
-#define O_RDWR    0X02  ///< Open for reading and writing.
-#define O_AT_END  0X04  ///< Open at EOF.
-#define O_APPEND  0X08  ///< Set append mode.
-#define O_CREAT   0x10  ///< Create file if it does not exist.
-#define O_TRUNC   0x20  ///< Truncate file to zero length.
-#define O_EXCL    0x40  ///< Fail if the file exists.
-#define O_SYNC    0x80  ///< Synchronized write I/O operations.
-
-#define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)  ///< Mask for access mode.
-typedef uint8_t oflag_t;
-#endif  // USE_FCNTL_H
-
-#define O_READ    O_RDONLY
-#define O_WRITE   O_WRONLY
-
-inline bool isWriteMode(oflag_t oflag) {
-  oflag &= O_ACCMODE;
-  return oflag == O_WRONLY || oflag == O_RDWR;
-}
-
-// flags for ls()
-/** ls() flag for list all files including hidden. */
-const uint8_t LS_A = 1;
-/** ls() flag to print modify. date */
-const uint8_t LS_DATE = 2;
-/** ls() flag to print file size. */
-const uint8_t LS_SIZE = 4;
-/** ls() flag for recursive list of subdirectories */
-const uint8_t LS_R = 8;
-
-// flags for time-stamp
-/** set the file's last access date */
-const uint8_t T_ACCESS = 1;
-/** set the file's creation date and time */
-const uint8_t T_CREATE = 2;
-/** Set the file's write date and time */
-const uint8_t T_WRITE = 4;
-#endif  // FsApiConstants_h

lib/SdFat_NoArduino/src/common/FsBlockDevice.h

@@ -1,33 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsBlockDevice_h
-#define FsBlockDevice_h
-#include "SdCard/SdCard.h"
-#if HAS_SDIO_CLASS || USE_BLOCK_DEVICE_INTERFACE
-typedef FsBlockDeviceInterface FsBlockDevice;
-#else
-typedef SdCard FsBlockDevice;
-#endif
-#endif  // FsBlockDevice_h

lib/SdFat_NoArduino/src/common/FsBlockDeviceInterface.h

@@ -1,95 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief FsBlockDeviceInterface include file.
- */
-#ifndef FsBlockDeviceInterface_h
-#define FsBlockDeviceInterface_h
-#include <stdint.h>
-#include <stddef.h>
-/**
- * \class FsBlockDeviceInterface
- * \brief FsBlockDeviceInterface class.
- */
-class FsBlockDeviceInterface {
- public:
-  virtual ~FsBlockDeviceInterface() {}
-
-  /** end use of device */
-  virtual void end() {}
-  /**
-   * Check for FsBlockDevice busy.
-   *
-   * \return true if busy else false.
-   */
-  virtual bool isBusy() = 0;
-  /**
-   * Read a sector.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  virtual bool readSector(uint32_t sector, uint8_t* dst) = 0;
-
-  /**
-   * Read multiple sectors.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[in] ns Number of sectors to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  virtual bool readSectors(uint32_t sector, uint8_t* dst, size_t ns) = 0;
-
-  /** \return device size in sectors. */
-  virtual uint32_t sectorCount() = 0;
-
-  /** End multi-sector transfer and go to idle state.
-   * \return true for success or false for failure.
-   */
-  virtual bool syncDevice() = 0;
-
-  /**
-   * Writes a sector.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  virtual bool writeSector(uint32_t sector, const uint8_t* src) = 0;
-
-  /**
-   * Write multiple sectors.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] ns Number of sectors to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  virtual bool writeSectors(uint32_t sector, const uint8_t* src, size_t ns) = 0;
-};
-#endif  // FsBlockDeviceInterface_h

lib/SdFat_NoArduino/src/common/FsCache.cpp

@@ -1,75 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#define DBG_FILE "FsCache.cpp"
-#include "DebugMacros.h"
-#include "FsCache.h"
-//------------------------------------------------------------------------------
-uint8_t* FsCache::prepare(uint32_t sector, uint8_t option) {
-  if (!m_blockDev) {
-    DBG_FAIL_MACRO;
-    goto fail;
-  }
-  if (m_sector != sector) {
-    if (!sync()) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    if (!(option & CACHE_OPTION_NO_READ)) {
-      if (!m_blockDev->readSector(sector, m_buffer)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    m_status = 0;
-    m_sector = sector;
-  }
-  m_status |= option & CACHE_STATUS_MASK;
-  return m_buffer;
-
- fail:
-  return nullptr;
-}
-//------------------------------------------------------------------------------
-bool FsCache::sync() {
-  if (m_status & CACHE_STATUS_DIRTY) {
-    if (!m_blockDev->writeSector(m_sector, m_buffer)) {
-      DBG_FAIL_MACRO;
-      goto fail;
-    }
-    // mirror second FAT
-    if (m_status & CACHE_STATUS_MIRROR_FAT) {
-      uint32_t sector = m_sector + m_mirrorOffset;
-      if (!m_blockDev->writeSector(sector, m_buffer)) {
-        DBG_FAIL_MACRO;
-        goto fail;
-      }
-    }
-    m_status &= ~CACHE_STATUS_DIRTY;
-  }
-  return true;
-
- fail:
-  return false;
-}

lib/SdFat_NoArduino/src/common/FsCache.h

@@ -1,184 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsCache_h
-#define FsCache_h
-/**
- * \file
- * \brief Common cache code for exFAT and FAT.
- */
-#include "SysCall.h"
-#include "FsBlockDevice.h"
-/**
- * \class FsCache
- * \brief Sector cache.
- */
-class FsCache {
- public:
-  /** Cached sector is dirty */
-  static const uint8_t CACHE_STATUS_DIRTY = 1;
-  /** Cashed sector is FAT entry and must be mirrored in second FAT. */
-  static const uint8_t CACHE_STATUS_MIRROR_FAT = 2;
-  /** Cache sector status bits */
-  static const uint8_t CACHE_STATUS_MASK =
-    CACHE_STATUS_DIRTY | CACHE_STATUS_MIRROR_FAT;
-  /** Sync existing sector but do not read new sector. */
-  static const uint8_t CACHE_OPTION_NO_READ = 4;
-  /** Cache sector for read. */
-  static const uint8_t CACHE_FOR_READ = 0;
-  /** Cache sector for write. */
-  static const uint8_t CACHE_FOR_WRITE = CACHE_STATUS_DIRTY;
-  /** Reserve cache sector for write - do not read from sector device. */
-  static const uint8_t CACHE_RESERVE_FOR_WRITE =
-    CACHE_STATUS_DIRTY | CACHE_OPTION_NO_READ;
-  //----------------------------------------------------------------------------
-  /** \return Cache buffer address. */
-  uint8_t* cacheBuffer() {
-    return m_buffer;
-  }
-  /**
-   * Cache safe read of a sector.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  bool cacheSafeRead(uint32_t sector, uint8_t* dst) {
-    if (isCached(sector)) {
-      memcpy(dst, m_buffer, 512);
-      return true;
-    }
-    return m_blockDev->readSector(sector, dst);
-  }
-  /**
-   * Cache safe read of multiple sectors.
-   *
-   * \param[in] sector Logical sector to be read.
-   * \param[in] count Number of sectors to be read.
-   * \param[out] dst Pointer to the location that will receive the data.
-   * \return true for success or false for failure.
-   */
-  bool cacheSafeRead(uint32_t sector, uint8_t* dst, size_t count) {
-    if (isCached(sector, count) && !sync()) {
-      return false;
-    }
-    return m_blockDev->readSectors(sector, dst, count);
-  }
-  /**
-   * Cache safe write of a sectors.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \return true for success or false for failure.
-   */
-  bool cacheSafeWrite(uint32_t sector, const uint8_t* src) {
-    if (isCached(sector)) {
-      invalidate();
-    }
-    return m_blockDev->writeSector(sector, src);
-  }
-  /**
-   * Cache safe write of multiple sectors.
-   *
-   * \param[in] sector Logical sector to be written.
-   * \param[in] src Pointer to the location of the data to be written.
-   * \param[in] count Number of sectors to be written.
-   * \return true for success or false for failure.
-   */
-  bool cacheSafeWrite(uint32_t sector, const uint8_t* src, size_t count) {
-     if (isCached(sector, count)) {
-      invalidate();
-    }
-    return m_blockDev->writeSectors(sector, src, count);
-  }
-  /** \return Clear the cache and returns a pointer to the cache. */
-  uint8_t* clear() {
-    if (isDirty() && !sync()) {
-      return nullptr;
-    }
-    invalidate();
-    return m_buffer;
-  }
-  /** Set current sector dirty. */
-  void dirty() {
-    m_status |= CACHE_STATUS_DIRTY;
-  }
-  /** Initialize the cache.
-   * \param[in] blockDev Block device for this cache.
-   */
-  void init(FsBlockDevice* blockDev) {
-    m_blockDev = blockDev;
-    invalidate();
-  }
-  /** Invalidate current cache sector. */
-  void invalidate() {
-    m_status = 0;
-    m_sector = 0XFFFFFFFF;
-  }
-  /** Check if a sector is in the cache.
-   * \param[in] sector Sector to checked.
-   * \return true if the sector is cached.
-   */
-  bool isCached(uint32_t sector) const {return sector == m_sector;}
-   /** Check if the cache contains a sector from a range.
-   * \param[in] sector Start sector of the range.
-   * \param[in] count Number of sectors in the range.
-   * \return true if a sector in the range is cached.
-   */
-  bool isCached(uint32_t sector, size_t count) {
-    return sector <= m_sector && m_sector < (sector + count);
-  }
-  /** \return dirty status */
-  bool isDirty() {
-    return m_status & CACHE_STATUS_DIRTY;
-  }
-  /** Prepare cache to access sector.
-   * \param[in] sector Sector to read.
-   * \param[in] option mode for cached sector.
-   * \return Address of cached sector.
-   */
-  uint8_t* prepare(uint32_t sector, uint8_t option);
-  /** \return Logical sector number for cached sector. */
-  uint32_t sector() {
-    return m_sector;
-  }
-  /** Set the offset to the second FAT for mirroring.
-   * \param[in] offset Sector offset to second FAT.
-   */
-  void setMirrorOffset(uint32_t offset) {
-    m_mirrorOffset = offset;
-  }
-  /** Write current sector if dirty.
-   * \return true for success or false for failure.
-   */
-  bool sync();
-
- private:
-  uint8_t m_status;
-  FsBlockDevice* m_blockDev;
-  uint32_t m_mirrorOffset;
-  uint32_t m_sector;
-  uint8_t m_buffer[512];
-};
-#endif  // FsCache_h

lib/SdFat_NoArduino/src/common/FsDateTime.cpp

@@ -1,175 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "SysCall.h"
-#include "FsDateTime.h"
-#include "FmtNumber.h"
-
-static void dateTimeMs10(uint16_t* date, uint16_t* time, uint8_t* ms10) {
-  *ms10 = 0;
-  FsDateTime::callback2(date, time);
-}
-//------------------------------------------------------------------------------
-/** Date time callback. */
-namespace FsDateTime {
-  void (*callback)(uint16_t* date, uint16_t* time, uint8_t* ms10) = nullptr;
-  void (*callback2)(uint16_t* date, uint16_t* time) = nullptr;
-  void clearCallback() {
-    callback = nullptr;
-  }
-  void setCallback(void (*dateTime)(uint16_t* date, uint16_t* time)) {
-    callback = dateTimeMs10;
-    callback2 = dateTime;
-  }
-  void setCallback(
-    void (*dateTime)(uint16_t* date, uint16_t* time, uint8_t* ms10)) {
-    callback = dateTime;
-  }
-}  // namespace FsDateTime
-//------------------------------------------------------------------------------
-static char* fsFmtField(char* str, uint16_t n, char sep) {
-  if (sep) {
-    *--str = sep;
-  }
-  str = fmtBase10(str, n);
-  if (n < 10) {
-    *--str = '0';
-  }
-  return str;
-}
-//------------------------------------------------------------------------------
-char* fsFmtDate(char* str, uint16_t date) {
-  str = fsFmtField(str, date & 31, 0);
-  date >>= 5;
-  str = fsFmtField(str, date & 15, '-');
-  date >>= 4;
-  return fsFmtField(str, 1980 + date, '-');
-}
-//------------------------------------------------------------------------------
-char* fsFmtTime(char* str, uint16_t time) {
-  time >>= 5;
-  str = fsFmtField(str, time & 63, 0);
-  return fsFmtField(str, time >> 6, ':');
-}
-//------------------------------------------------------------------------------
-char* fsFmtTime(char* str, uint16_t time, uint8_t sec100) {
-  str = fsFmtField(str, 2*(time & 31) + (sec100 < 100 ? 0 : 1), 0);
-  *--str = ':';
-  return fsFmtTime(str, time);
-}
-//------------------------------------------------------------------------------
-char* fsFmtTimeZone(char* str, int8_t tz) {
-  char sign;
-  if (tz & 0X80) {
-    if (tz & 0X40) {
-      sign = '-';
-      tz = -tz;
-    } else {
-      sign = '+';
-      tz &= 0X7F;
-    }
-    if (tz) {
-      str = fsFmtField(str, 15*(tz%4), 0);
-      str = fsFmtField(str, tz/4, ':');
-      *--str = sign;
-    }
-    *--str = 'C';
-    *--str = 'T';
-    *--str = 'U';
-  }
-  return str;
-}
-//------------------------------------------------------------------------------
-size_t fsPrintDate(print_t* pr, uint16_t date) {
-  // Allow YYYY-MM-DD
-  char buf[sizeof("YYYY-MM-DD") -1];
-  char* str = buf + sizeof(buf);
-  if (date) {
-    str = fsFmtDate(str, date);
-  } else {
-     do {
-      *--str = ' ';
-    } while (str > buf);
-  }
-  return pr->write(reinterpret_cast<uint8_t*>(str), buf + sizeof(buf) - str);
-}
-//------------------------------------------------------------------------------
-size_t fsPrintDateTime(print_t* pr, uint16_t date, uint16_t time) {
-  // Allow YYYY-MM-DD hh:mm
-  char buf[sizeof("YYYY-MM-DD hh:mm") -1];
-  char* str = buf + sizeof(buf);
-  if (date) {
-    str = fsFmtTime(str, time);
-    *--str = ' ';
-    str = fsFmtDate(str, date);
-  } else {
-    do {
-      *--str = ' ';
-    } while (str > buf);
-  }
-  return pr->write(reinterpret_cast<uint8_t*>(str), buf + sizeof(buf) - str);
-}
-//------------------------------------------------------------------------------
-size_t fsPrintDateTime(print_t* pr, uint32_t dateTime) {
-  return fsPrintDateTime(pr, dateTime >> 16, dateTime & 0XFFFF);
-}
-//------------------------------------------------------------------------------
-size_t fsPrintDateTime(print_t* pr,
-                       uint32_t dateTime, uint8_t s100, int8_t tz) {
-  // Allow YYYY-MM-DD hh:mm:ss UTC+hh:mm
-  char buf[sizeof("YYYY-MM-DD hh:mm:ss UTC+hh:mm") -1];
-  char* str = buf + sizeof(buf);
-  if (tz) {
-    str = fsFmtTimeZone(str, tz);
-    *--str = ' ';
-  }
-  str = fsFmtTime(str, (uint16_t)dateTime, s100);
-  *--str = ' ';
-  str = fsFmtDate(str, (uint16_t)(dateTime >> 16));
-  return pr->write(reinterpret_cast<uint8_t*>(str), buf + sizeof(buf) - str);
-}
-//------------------------------------------------------------------------------
-size_t fsPrintTime(print_t* pr, uint16_t time) {
-  // Allow hh:mm
-  char buf[sizeof("hh:mm") -1];
-  char* str = buf + sizeof(buf);
-  str = fsFmtTime(str, time);
-  return pr->write(reinterpret_cast<uint8_t*>(str), buf + sizeof(buf) - str);
-}
-//------------------------------------------------------------------------------
-size_t fsPrintTime(print_t* pr, uint16_t time, uint8_t sec100) {
-  // Allow hh:mm:ss
-  char buf[sizeof("hh:mm:ss") -1];
-  char* str = buf + sizeof(buf);
-  str = fsFmtTime(str, time, sec100);
-  return pr->write(reinterpret_cast<uint8_t*>(str), buf + sizeof(buf) - str);
-}
-//------------------------------------------------------------------------------
-size_t fsPrintTimeZone(print_t* pr, int8_t tz) {
-  // Allow UTC+hh:mm
-  char buf[sizeof("UTC+hh:mm") -1];
-  char* str = buf + sizeof(buf);
-  str = fsFmtTimeZone(str, tz);
-  return pr->write(reinterpret_cast<uint8_t*>(str), buf + sizeof(buf) - str);
-}

lib/SdFat_NoArduino/src/common/FsDateTime.h

@@ -1,193 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsDateTime_h
-#define FsDateTime_h
-#include <stdint.h>
-#include "CompileDateTime.h"
-#include "SysCall.h"
-
-/** Backward compatible definition. */
-#define FAT_DATE(y, m, d) FS_DATE(y, m, d)
-
-/** Backward compatible definition. */
-#define FAT_TIME(h, m, s) FS_TIME(h, m, s)
-
-/** Date time callback */
-namespace FsDateTime {
-  /** Date time callback. */
-  extern void (*callback)(uint16_t* date, uint16_t* time, uint8_t* ms10);
-  /** Date time callback. */
-  extern void (*callback2)(uint16_t* date, uint16_t* time);
-  /** Cancel callback. */
-  void clearCallback();
-   /** Set the date/time callback function.
-   *
-   * \param[in] dateTime The user's call back function.  The callback.
-   * function is of the form:
-   *
-   * \code
-   * void dateTime(uint16_t* date, uint16_t* time) {
-   *   uint16_t year;
-   *   uint8_t month, day, hour, minute, second;
-   *
-   *   // User gets date and time from GPS or real-time clock here.
-   *
-   *   // Return date using FS_DATE macro to format fields.
-   *   *date = FS_DATE(year, month, day);
-   *
-   *   // Return time using FS_TIME macro to format fields.
-   *   *time = FS_TIME(hour, minute, second);
-   * }
-   * \endcode
-   *
-   * Sets the function that is called when a file is created or when
-   * a file's directory entry is modified by sync(). All timestamps,
-   * access, creation, and modify, are set when a file is created.
-   * sync() maintains the last access date and last modify date/time.
-   *
-   */
-  void setCallback(void (*dateTime)(uint16_t* date, uint16_t* time));
-   /** Set the date/time callback function.
-   *
-   * \param[in] dateTime The user's call back function.  The callback
-   * function is of the form:
-   *
-   * \code
-   * void dateTime(uint16_t* date, uint16_t* time, uint8_t* ms10) {
-   *   uint16_t year;
-   *   uint8_t month, day, hour, minute, second;
-   *
-   *   // User gets date and time from GPS or real-time clock here.
-   *
-   *   // Return date using FS_DATE macro to format fields
-   *   *date = FS_DATE(year, month, day);
-   *
-   *   // Return time using FS_TIME macro to format fields
-   *   *time = FS_TIME(hour, minute, second);
-   *
-   *   // Return the time since the last even second in units of 10 ms.
-   *   // The granularity of the seconds part of FS_TIME is 2 seconds so
-   *   // this field is a count of hundredth of a second and its valid
-   *   // range is 0-199 inclusive.
-   *   // For a simple RTC return 100*(seconds & 1).
-   *   *ms10 = <tens of ms since even second>
-   * }
-   * \endcode
-   *
-   * Sets the function that is called when a file is created or when
-   * a file's directory entry is modified by sync(). All timestamps,
-   * access, creation, and modify, are set when a file is created.
-   * sync() maintains the last access date and last modify date/time.
-   *
-   */
-  void setCallback(
-    void (*dateTime)(uint16_t* date, uint16_t* time, uint8_t* ms10));
-}  // namespace FsDateTime
-
-/** date field for directory entry
- * \param[in] year [1980,2107]
- * \param[in] month [1,12]
- * \param[in] day [1,31]
- *
- * \return Packed date for directory entry.
- */
-static inline uint16_t FS_DATE(uint16_t year, uint8_t month, uint8_t day) {
-  year -= 1980;
-  return year > 127 || month > 12 || day > 31 ? 0 :
-         year << 9 | month << 5 | day;
-}
-/** year part of FAT directory date field
- * \param[in] fatDate Date in packed dir format.
- *
- * \return Extracted year [1980,2107]
- */
-static inline uint16_t FS_YEAR(uint16_t fatDate) {
-  return 1980 + (fatDate >> 9);
-}
-/** month part of FAT directory date field
- * \param[in] fatDate Date in packed dir format.
- *
- * \return Extracted month [1,12]
- */
-static inline uint8_t FS_MONTH(uint16_t fatDate) {
-  return (fatDate >> 5) & 0XF;
-}
-/** day part of FAT directory date field
- * \param[in] fatDate Date in packed dir format.
- *
- * \return Extracted day [1,31]
- */
-static inline uint8_t FS_DAY(uint16_t fatDate) {
-  return fatDate & 0X1F;
-}
-/** time field for directory entry
- * \param[in] hour [0,23]
- * \param[in] minute [0,59]
- * \param[in] second [0,59]
- *
- * \return Packed time for directory entry.
- */
-static inline uint16_t FS_TIME(uint8_t hour, uint8_t minute, uint8_t second) {
-  return hour > 23 || minute > 59 || second > 59 ? 0 :
-         hour << 11 | minute << 5 | second >> 1;
-}
-/** hour part of FAT directory time field
- * \param[in] fatTime Time in packed dir format.
- *
- * \return Extracted hour [0,23]
- */
-static inline uint8_t FS_HOUR(uint16_t fatTime) {
-  return fatTime >> 11;
-}
-/** minute part of FAT directory time field
- * \param[in] fatTime Time in packed dir format.
- *
- * \return Extracted minute [0,59]
- */
-static inline uint8_t FS_MINUTE(uint16_t fatTime) {
-  return (fatTime >> 5) & 0X3F;
-}
-/** second part of FAT directory time field
- * N\note second/2 is stored in packed time.
- *
- * \param[in] fatTime Time in packed dir format.
- *
- * \return Extracted second [0,58]
- */
-static inline uint8_t FS_SECOND(uint16_t fatTime) {
-  return 2*(fatTime & 0X1F);
-}
-char* fsFmtDate(char* str, uint16_t date);
-char* fsFmtTime(char* str, uint16_t time);
-char* fsFmtTime(char* str, uint16_t time, uint8_t sec100);
-char* fsFmtTimeZone(char* str, int8_t tz);
-size_t fsPrintDate(print_t* pr, uint16_t date);
-size_t fsPrintDateTime(print_t* pr, uint16_t date, uint16_t time);
-size_t fsPrintDateTime(print_t* pr, uint32_t dateTime);
-size_t fsPrintDateTime(print_t* pr, uint32_t dateTime, uint8_t s100, int8_t tz);
-size_t fsPrintTime(print_t* pr, uint16_t time);
-size_t fsPrintTime(print_t* pr, uint16_t time, uint8_t sec100);
-size_t fsPrintTimeZone(print_t* pr, int8_t tz);
-#endif  // FsDateTime_h

lib/SdFat_NoArduino/src/common/FsName.cpp

@@ -1,54 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FsName.h"
-#include "FsUtf.h"
-#if USE_UTF8_LONG_NAMES
-uint16_t FsName::get16() {
-  uint16_t rtn;
-  if (ls) {
-    rtn = ls;
-    ls = 0;
-  } else if (next >= end) {
-    rtn = 0;
-  } else {
-    uint32_t cp;
-    const char* ptr = FsUtf::mbToCp(next, end, &cp);
-    if (!ptr) {
-      goto fail;
-    }
-    next = ptr;
-    if (cp <= 0XFFFF) {
-      rtn = cp;
-    } else {
-      ls = FsUtf::lowSurrogate(cp);
-      rtn = FsUtf::highSurrogate(cp);
-    }
-  }
-  return rtn;
-
- fail:
-  return 0XFFFF;
-}
-#endif  // USE_UTF8_LONG_NAMES

lib/SdFat_NoArduino/src/common/FsName.h

@@ -1,66 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsName_h
-#define FsName_h
-#include "SysCall.h"
-#include <stdint.h>
-/**
- * \file
- * \brief FsName class.
- */
-/**
- * \class FsName
- * \brief Handle UTF-8 file names.
- */
-class FsName {
- public:
-  /** Beginning of LFN. */
-  const char* begin;
-  /** Next LFN character of end. */
-  const char* next;
-  /** Position one beyond last LFN character. */
-  const char* end;
-#if !USE_UTF8_LONG_NAMES
-  /** \return true if at end. */
-  bool atEnd() {return next == end;}
-  /** Reset to start of LFN. */
-  void reset() {next = begin;}
-  /** \return next char of LFN. */
-  char getch() {return atEnd() ? 0 : *next++;}
-  /** \return next UTF-16 unit of LFN. */
-  uint16_t get16() {return atEnd() ? 0 : *next++;}
-#else  // !USE_UTF8_LONG_NAMES
-  uint16_t ls = 0;
-  bool atEnd() {
-    return !ls && next == end;
-  }
-  void reset() {
-    next = begin;
-    ls = 0;  // lowSurrogate
-  }
-  uint16_t get16();
-#endif  // !USE_UTF8_LONG_NAMES
-};
-#endif  // FsName_h

lib/SdFat_NoArduino/src/common/FsStructs.cpp

@@ -1,64 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FsStructs.h"
-// bgnLba = relSector;
-// endLba = relSector + partSize - 1;
-void lbaToMbrChs(uint8_t* chs, uint32_t capacityMB, uint32_t lba) {
-  uint32_t c;
-  uint8_t h;
-  uint8_t s;
-
-  uint8_t numberOfHeads;
-  uint8_t sectorsPerTrack = capacityMB <= 256 ? 32 : 63;
-  if (capacityMB <= 16) {
-    numberOfHeads = 2;
-  } else if (capacityMB <= 32) {
-    numberOfHeads = 4;
-  } else if (capacityMB <= 128) {
-    numberOfHeads = 8;
-  } else if (capacityMB <= 504) {
-    numberOfHeads = 16;
-  } else if (capacityMB <= 1008) {
-    numberOfHeads = 32;
-  } else if (capacityMB <= 2016) {
-    numberOfHeads = 64;
-  } else if (capacityMB <= 4032) {
-    numberOfHeads = 128;
-  } else {
-    numberOfHeads = 255;
-  }
-  c = lba / (numberOfHeads * sectorsPerTrack);
-  if (c <= 1023) {
-    h = (lba % (numberOfHeads * sectorsPerTrack)) / sectorsPerTrack;
-    s = (lba % sectorsPerTrack) + 1;
-  } else {
-    c = 1023;
-    h = 254;
-    s = 63;
-  }
-  chs[0] = h;
-  chs[1] = ((c >> 2) & 0XC0) | s;
-  chs[2] = c;
-}

lib/SdFat_NoArduino/src/common/FsStructs.h

@@ -1,446 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsStructs_h
-#define FsStructs_h
-#include <stddef.h>
-#include <stdint.h>
-//------------------------------------------------------------------------------
-void lbaToMbrChs(uint8_t* chs, uint32_t capacityMB, uint32_t lba);
-//------------------------------------------------------------------------------
-#if !defined(USE_SIMPLE_LITTLE_ENDIAN) || USE_SIMPLE_LITTLE_ENDIAN
-// assumes CPU is little-endian and handles alignment issues.
-inline uint16_t getLe16(const uint8_t* src) {
-  return *reinterpret_cast<const uint16_t*>(src);
-}
-inline uint32_t getLe32(const uint8_t* src) {
-  return *reinterpret_cast<const uint32_t*>(src);
-}
-inline uint64_t getLe64(const uint8_t* src) {
-  return *reinterpret_cast<const uint64_t*>(src);
-}
-inline void setLe16(uint8_t* dst, uint16_t src) {
-  *reinterpret_cast<uint16_t*>(dst) = src;
-}
-inline void setLe32(uint8_t* dst, uint32_t src) {
-  *reinterpret_cast<uint32_t*>(dst) = src;
-}
-inline void setLe64(uint8_t* dst, uint64_t src) {
-  *reinterpret_cast<uint64_t*>(dst) = src;
-}
-#else  // USE_SIMPLE_LITTLE_ENDIAN
-inline uint16_t getLe16(const uint8_t* src) {
-  return (uint16_t)src[0] << 0 |
-         (uint16_t)src[1] << 8;
-}
-inline uint32_t getLe32(const uint8_t* src) {
-  return (uint32_t)src[0] <<  0 |
-         (uint32_t)src[1] <<  8 |
-         (uint32_t)src[2] << 16 |
-         (uint32_t)src[3] << 24;
-}
-inline uint64_t getLe64(const uint8_t* src) {
-  return (uint64_t)src[0] <<  0 |
-         (uint64_t)src[1] <<  8 |
-         (uint64_t)src[2] << 16 |
-         (uint64_t)src[3] << 24 |
-         (uint64_t)src[4] << 32 |
-         (uint64_t)src[5] << 40 |
-         (uint64_t)src[6] << 48 |
-         (uint64_t)src[7] << 56;
-}
-inline void setLe16(uint8_t* dst, uint16_t src) {
-  dst[0] = src >>  0;
-  dst[1] = src >>  8;
-}
-inline void setLe32(uint8_t* dst, uint32_t src) {
-  dst[0] = src >>  0;
-  dst[1] = src >>  8;
-  dst[2] = src >> 16;
-  dst[3] = src >> 24;
-}
-inline void setLe64(uint8_t* dst, uint64_t src) {
-  dst[0] = src >>  0;
-  dst[1] = src >>  8;
-  dst[2] = src >> 16;
-  dst[3] = src >> 24;
-  dst[4] = src >> 32;
-  dst[5] = src >> 40;
-  dst[6] = src >> 48;
-  dst[7] = src >> 56;
-}
-#endif  // USE_SIMPLE_LITTLE_ENDIAN
-//------------------------------------------------------------------------------
-// Size of FAT and exFAT directory structures.
-const size_t FS_DIR_SIZE = 32;
-//------------------------------------------------------------------------------
-// Reserved characters for exFAT names and FAT LFN.
-inline bool lfnReservedChar(uint8_t c) {
-  return c < 0X20 || c == '"' || c == '*' || c == '/' || c == ':'
-    || c == '<' || c == '>' || c == '?' || c == '\\'|| c == '|';
-}
-//------------------------------------------------------------------------------
-// Reserved characters for FAT short 8.3 names.
-inline bool sfnReservedChar(uint8_t c) {
-  if (c == '"' || c == '|' || c == '[' || c == '\\' || c == ']') {
-    return true;
-  }
-  //  *+,./ or :;<=>?
-  if ((0X2A <= c && c <= 0X2F && c != 0X2D) || (0X3A <= c && c <= 0X3F)) {
-    return true;
-  }
-  // Reserved if not in range (0X20, 0X7F).
-  return !(0X20 < c && c < 0X7F);
-}
-//------------------------------------------------------------------------------
-const uint16_t MBR_SIGNATURE = 0xAA55;
-const uint16_t PBR_SIGNATURE = 0xAA55;
-
-typedef struct mbrPartition {
-  uint8_t boot;
-  uint8_t beginCHS[3];
-  uint8_t type;
-  uint8_t endCHS[3];
-  uint8_t relativeSectors[4];
-  uint8_t totalSectors[4];
-} MbrPart_t;
-//------------------------------------------------------------------------------
-typedef struct masterBootRecordSector {
-  uint8_t   bootCode[446];
-  MbrPart_t part[4];
-  uint8_t   signature[2];
-} MbrSector_t;
-//------------------------------------------------------------------------------
-// GPT partition structures based on https://github.com/KirollousMoheb/GUID-Partition-Table-Parser
-// Copyright (c) 2022 Kirollous Moheb, under MIT License
-typedef struct
-{
-  uint8_t part_type_guid[16];
-  uint8_t unique_part_guid[16];
-  uint8_t first_lba[8];
-  uint8_t last_lba[8];
-  uint8_t attr_flags[8];
-  uint8_t part_name[72];
-} GPT_PartitionEntry_t;
-//------------------------------------------------------------------------------
-typedef struct
-{
-  uint8_t signature[8];
-  uint8_t revision[4];
-  uint8_t header_size[4];
-  uint8_t crc32[4];
-  uint8_t reserved[4];
-  uint8_t current_lba[8];
-  uint8_t backup_lba[8];
-  uint8_t first_usable_lba[8];
-  uint8_t last_usable_lba[8];
-  uint8_t disk_guid[16];
-  uint8_t part_entry_start_lba[8];
-  uint8_t num_part_entries[4];
-  uint8_t part_entry_size[4];
-  uint8_t crc32_part_array[4];
-} GPT_Header_t;
-//------------------------------------------------------------------------------
-typedef struct partitionBootSector {
-  uint8_t  jmpInstruction[3];
-  char     oemName[8];
-  uint8_t  bpb[109];
-  uint8_t  bootCode[390];
-  uint8_t  signature[2];
-} pbs_t;
-//------------------------------------------------------------------------------
-typedef struct {
-  uint8_t type;
-  uint8_t data[31];
-} DirGeneric_t;
-//==============================================================================
-typedef struct {
-  uint64_t position;
-  uint32_t cluster;
-} fspos_t;
-//==============================================================================
-const uint8_t EXTENDED_BOOT_SIGNATURE = 0X29;
-typedef struct biosParameterBlockFat16 {
-  uint8_t  bytesPerSector[2];
-  uint8_t  sectorsPerCluster;
-  uint8_t  reservedSectorCount[2];
-  uint8_t  fatCount;
-  uint8_t  rootDirEntryCount[2];
-  uint8_t  totalSectors16[2];
-  uint8_t  mediaType;
-  uint8_t  sectorsPerFat16[2];
-  uint8_t  sectorsPerTrtack[2];
-  uint8_t  headCount[2];
-  uint8_t  hidddenSectors[4];
-  uint8_t  totalSectors32[4];
-
-  uint8_t  physicalDriveNumber;
-  uint8_t  extReserved;
-  uint8_t  extSignature;
-  uint8_t  volumeSerialNumber[4];
-  uint8_t  volumeLabel[11];
-  uint8_t  volumeType[8];
-} BpbFat16_t;
-//------------------------------------------------------------------------------
-typedef struct biosParameterBlockFat32 {
-  uint8_t  bytesPerSector[2];
-  uint8_t  sectorsPerCluster;
-  uint8_t  reservedSectorCount[2];
-  uint8_t  fatCount;
-  uint8_t  rootDirEntryCount[2];
-  uint8_t  totalSectors16[2];
-  uint8_t  mediaType;
-  uint8_t  sectorsPerFat16[2];
-  uint8_t  sectorsPerTrtack[2];
-  uint8_t  headCount[2];
-  uint8_t  hidddenSectors[4];
-  uint8_t  totalSectors32[4];
-
-  uint8_t  sectorsPerFat32[4];
-  uint8_t  fat32Flags[2];
-  uint8_t  fat32Version[2];
-  uint8_t  fat32RootCluster[4];
-  uint8_t  fat32FSInfoSector[2];
-  uint8_t  fat32BackBootSector[2];
-  uint8_t  fat32Reserved[12];
-
-  uint8_t  physicalDriveNumber;
-  uint8_t  extReserved;
-  uint8_t  extSignature;
-  uint8_t  volumeSerialNumber[4];
-  uint8_t  volumeLabel[11];
-  uint8_t  volumeType[8];
-} BpbFat32_t;
-//------------------------------------------------------------------------------
-typedef struct partitionBootSectorFat {
-  uint8_t  jmpInstruction[3];
-  char     oemName[8];
-  union {
-    uint8_t bpb[109];
-    BpbFat16_t bpb16;
-    BpbFat32_t bpb32;
-  } bpb;
-  uint8_t  bootCode[390];
-  uint8_t  signature[2];
-} PbsFat_t;
-//------------------------------------------------------------------------------
-const uint32_t FSINFO_LEAD_SIGNATURE = 0X41615252;
-const uint32_t FSINFO_STRUCT_SIGNATURE = 0x61417272;
-const uint32_t FSINFO_TRAIL_SIGNATURE = 0xAA550000;
-typedef struct FsInfoSector {
-  uint8_t leadSignature[4];
-  uint8_t reserved1[480];
-  uint8_t structSignature[4];
-  uint8_t freeCount[4];
-  uint8_t nextFree[4];
-  uint8_t reserved2[12];
-  uint8_t trailSignature[4];
-} FsInfo_t;
-//==============================================================================
-/** Attributes common to FAT and exFAT */
-const uint8_t FS_ATTRIB_READ_ONLY = 0x01;
-const uint8_t FS_ATTRIB_HIDDEN    = 0x02;
-const uint8_t FS_ATTRIB_SYSTEM    = 0x04;
-const uint8_t FS_ATTRIB_DIRECTORY = 0x10;
-const uint8_t FS_ATTRIB_ARCHIVE   = 0x20;
-// Attributes that users can change.
-const uint8_t FS_ATTRIB_USER_SETTABLE = FS_ATTRIB_READ_ONLY |
-  FS_ATTRIB_HIDDEN | FS_ATTRIB_SYSTEM | FS_ATTRIB_ARCHIVE;
-// Attributes to copy when a file is opened.
-const uint8_t FS_ATTRIB_COPY = FS_ATTRIB_USER_SETTABLE | FS_ATTRIB_DIRECTORY;
-//==============================================================================
-/** name[0] value for entry that is free and no allocated entries follow */
-const uint8_t FAT_NAME_FREE = 0X00;
-/** name[0] value for entry that is free after being "deleted" */
-const uint8_t FAT_NAME_DELETED = 0XE5;
-// Directiry attribute of volume label.
-const uint8_t FAT_ATTRIB_LABEL     = 0x08;
-const uint8_t FAT_ATTRIB_LONG_NAME = 0X0F;
-/** Filename base-name is all lower case */
-const uint8_t FAT_CASE_LC_BASE = 0X08;
-/** Filename extension is all lower case.*/
-const uint8_t FAT_CASE_LC_EXT = 0X10;
-
-typedef struct {
-  uint8_t  name[11];
-  uint8_t  attributes;
-  uint8_t  caseFlags;
-  uint8_t  createTimeMs;
-  uint8_t  createTime[2];
-  uint8_t  createDate[2];
-  uint8_t  accessDate[2];
-  uint8_t  firstClusterHigh[2];
-  uint8_t  modifyTime[2];
-  uint8_t  modifyDate[2];
-  uint8_t  firstClusterLow[2];
-  uint8_t  fileSize[4];
-} DirFat_t;
-
-static inline bool isFatFile(const DirFat_t* dir) {
-  return (dir->attributes & (FS_ATTRIB_DIRECTORY | FAT_ATTRIB_LABEL)) == 0;
-}
-static inline bool isFatFileOrSubdir(const DirFat_t* dir) {
-  return (dir->attributes & FAT_ATTRIB_LABEL) == 0;
-}
-static inline uint8_t isFatLongName(const DirFat_t* dir) {
-  return dir->attributes == FAT_ATTRIB_LONG_NAME;
-}
-static inline bool isFatSubdir(const DirFat_t* dir) {
-  return (dir->attributes & (FS_ATTRIB_DIRECTORY | FAT_ATTRIB_LABEL))
-          == FS_ATTRIB_DIRECTORY;
-}
-//------------------------------------------------------------------------------
-/**
- * Order mask that indicates the entry is the last long dir entry in a
- * set of long dir entries. All valid sets of long dir entries must
- * begin with an entry having this mask.
- */
-const uint8_t FAT_ORDER_LAST_LONG_ENTRY = 0X40;
-/** Max long file name length */
-
-const uint8_t FAT_MAX_LFN_LENGTH = 255;
-typedef struct {
-  uint8_t  order;
-  uint8_t  unicode1[10];
-  uint8_t  attributes;
-  uint8_t  mustBeZero1;
-  uint8_t  checksum;
-  uint8_t  unicode2[12];
-  uint8_t  mustBeZero2[2];
-  uint8_t  unicode3[4];
-} DirLfn_t;
-//==============================================================================
-inline uint32_t exFatChecksum(uint32_t sum, uint8_t data) {
-  return (sum << 31) + (sum >> 1) + data;
-}
-//------------------------------------------------------------------------------
-typedef struct biosParameterBlockExFat {
-  uint8_t mustBeZero[53];
-  uint8_t partitionOffset[8];
-  uint8_t volumeLength[8];
-  uint8_t fatOffset[4];
-  uint8_t fatLength[4];
-  uint8_t clusterHeapOffset[4];
-  uint8_t clusterCount[4];
-  uint8_t rootDirectoryCluster[4];
-  uint8_t volumeSerialNumber[4];
-  uint8_t fileSystemRevision[2];
-  uint8_t volumeFlags[2];
-  uint8_t bytesPerSectorShift;
-  uint8_t sectorsPerClusterShift;
-  uint8_t numberOfFats;
-  uint8_t driveSelect;
-  uint8_t percentInUse;
-  uint8_t reserved[7];
-} BpbExFat_t;
-//------------------------------------------------------------------------------
-typedef struct ExFatBootSector {
-  uint8_t  jmpInstruction[3];
-  char     oemName[8];
-  BpbExFat_t  bpb;
-  uint8_t  bootCode[390];
-  uint8_t  signature[2];
-} ExFatPbs_t;
-//------------------------------------------------------------------------------
-const uint32_t EXFAT_EOC = 0XFFFFFFFF;
-
-const uint8_t EXFAT_TYPE_BITMAP = 0X81;
-typedef struct {
-  uint8_t  type;
-  uint8_t  flags;
-  uint8_t  reserved[18];
-  uint8_t  firstCluster[4];
-  uint8_t  size[8];
-} DirBitmap_t;
-//------------------------------------------------------------------------------
-const uint8_t EXFAT_TYPE_UPCASE = 0X82;
-typedef struct {
-  uint8_t  type;
-  uint8_t  reserved1[3];
-  uint8_t  checksum[4];
-  uint8_t  reserved2[12];
-  uint8_t  firstCluster[4];
-  uint8_t  size[8];
-} DirUpcase_t;
-//------------------------------------------------------------------------------
-const uint8_t EXFAT_TYPE_LABEL = 0X83;
-typedef struct {
-  uint8_t  type;
-  uint8_t  labelLength;
-  uint8_t  unicode[22];
-  uint8_t  reserved[8];
-} DirLabel_t;
-//------------------------------------------------------------------------------
-// Last entry in directory.
-const uint8_t EXFAT_TYPE_END_DIR     = 0X00;
-// Entry is used if bit is set.
-const uint8_t EXFAT_TYPE_USED        = 0X80;
-const uint8_t EXFAT_TYPE_FILE        = 0X85;
-// File attribute reserved since used for FAT volume label.
-const uint8_t EXFAT_ATTRIB_RESERVED  = 0x08;
-
-typedef struct {
-  uint8_t  type;
-  uint8_t  setCount;
-  uint8_t  setChecksum[2];
-  uint8_t  attributes[2];
-  uint8_t  reserved1[2];
-  uint8_t  createTime[2];
-  uint8_t  createDate[2];
-  uint8_t  modifyTime[2];
-  uint8_t  modifyDate[2];
-  uint8_t  accessTime[2];
-  uint8_t  accessDate[2];
-  uint8_t  createTimeMs;
-  uint8_t  modifyTimeMs;
-  uint8_t  createTimezone;
-  uint8_t  modifyTimezone;
-  uint8_t  accessTimezone;
-  uint8_t  reserved2[7];
-} DirFile_t;
-
-const uint8_t EXFAT_TYPE_STREAM     = 0XC0;
-const uint8_t EXFAT_FLAG_ALWAYS1    = 0x01;
-const uint8_t EXFAT_FLAG_CONTIGUOUS = 0x02;
-typedef struct {
-  uint8_t  type;
-  uint8_t  flags;
-  uint8_t  reserved1;
-  uint8_t  nameLength;
-  uint8_t  nameHash[2];
-  uint8_t  reserved2[2];
-  uint8_t  validLength[8];
-  uint8_t  reserved3[4];
-  uint8_t  firstCluster[4];
-  uint8_t  dataLength[8];
-} DirStream_t;
-
-const uint8_t EXFAT_TYPE_NAME = 0XC1;
-const uint8_t EXFAT_MAX_NAME_LENGTH = 255;
-typedef struct {
-  uint8_t  type;
-  uint8_t  mustBeZero;
-  uint8_t  unicode[30];
-} DirName_t;
-#endif  // FsStructs_h

lib/SdFat_NoArduino/src/common/FsUtf.cpp

@@ -1,115 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "FsUtf.h"
-namespace FsUtf {
-  //----------------------------------------------------------------------------
-  char* cpToMb(uint32_t cp, char* str, char* end) {
-    size_t n = end - str;
-    if (cp < 0X80) {
-      if (n < 1) goto fail;
-      *(str++) = static_cast<uint8_t>(cp);
-    } else if (cp < 0X800) {
-      if (n < 2) goto fail;
-      *(str++) = static_cast<uint8_t>((cp >> 6)          | 0XC0);
-      *(str++) = static_cast<uint8_t>((cp & 0X3F)        | 0X80);
-    } else if (cp < 0X10000) {
-      if (n < 3) goto fail;
-      *(str++) = static_cast<uint8_t>((cp >> 12)         | 0XE0);
-      *(str++) = static_cast<uint8_t>(((cp >> 6) & 0X3F) | 0X80);
-      *(str++) = static_cast<uint8_t>((cp & 0X3F)        | 0X80);
-    } else {
-       if (n < 4) goto fail;
-      *(str++) = static_cast<uint8_t>((cp >> 18)         | 0XF0);
-      *(str++) = static_cast<uint8_t>(((cp >> 12) & 0X3F)| 0X80);
-      *(str++) = static_cast<uint8_t>(((cp >> 6) & 0X3F) | 0X80);
-      *(str++) = static_cast<uint8_t>((cp & 0X3F)        | 0X80);
-    }
-    return str;
-
-   fail:
-    return nullptr;
-  }
-  //----------------------------------------------------------------------------
-  // to do?  improve error check
-  const char* mbToCp(const char* str, const char* end, uint32_t* rtn) {
-    size_t n;
-    uint32_t cp;
-    if (str >= end) {
-      return nullptr;
-    }
-    uint8_t ch = str[0];
-    if ((ch & 0X80) == 0) {
-      *rtn = ch;
-      return str + 1;
-    }
-    if ((ch & 0XE0) == 0XC0) {
-      cp = ch & 0X1F;
-      n = 2;
-    } else if ((ch & 0XF0) == 0XE0) {
-      cp = ch & 0X0F;
-      n = 3;
-    } else if ((ch & 0XF8) == 0XF0) {
-      cp = ch & 0X07;
-      n = 4;
-    } else {
-      return nullptr;
-    }
-    if ((str + n) > end) {
-      return nullptr;
-    }
-    for (size_t i = 1; i < n; i++) {
-      ch = str[i];
-      if ((ch & 0XC0) != 0X80) {
-        return nullptr;
-      }
-      cp <<= 6;
-      cp |= ch & 0X3F;
-    }
-    // Don't allow over long as ASCII.
-    if (cp < 0X80 || !isValidCp(cp)) {
-      return nullptr;
-    }
-    *rtn = cp;
-    return str + n;
-  }
-  //----------------------------------------------------------------------------
-  const char* mbToU16(const char* str,
-                      const char* end, uint16_t* hs, uint16_t* ls) {
-    uint32_t cp;
-    const char* ptr = mbToCp(str, end, &cp);
-    if (!ptr) {
-      return nullptr;
-    }
-    if (cp <= 0XFFFF) {
-      *hs = cp;
-      *ls = 0;
-    } else {
-      *hs = highSurrogate(cp);
-      *ls = lowSurrogate(cp);
-    }
-    return ptr;
-  }
-}  // namespace FsUtf
-

lib/SdFat_NoArduino/src/common/FsUtf.h

@@ -1,109 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef FsUtf_h
-#define FsUtf_h
-/**
-* \file
-* \brief Unicode Transformation Format functions.
-*/
-#include <stdint.h>
-#include <stddef.h>
-namespace FsUtf {
-  /** High surrogate for a code point.
-   * \param{in} cp code point.
-   * \return high surrogate.
-   */
-  inline uint16_t highSurrogate(uint32_t cp) {
-    return (cp >> 10) + (0XD800 - (0X10000 >> 10));
-  }
-  /** Low surrogate for a code point.
-   * \param{in} cp code point.
-   * \return low surrogate.
-   */
-  inline uint16_t lowSurrogate(uint32_t cp) {
-    return (cp & 0X3FF) + 0XDC00;
-  }
-  /** Check for a valid code point.
-   * \param[in] cp code point.
-   * \return true if valid else false.
-   */
-  inline bool isValidCp(uint32_t cp) {
-    return cp <= 0x10FFFF && (cp < 0XD800 || cp > 0XDFFF);
-  }
-  /** Check for UTF-16 surrogate.
-   * \param[in] c UTF-16 unit.
-   * \return true if c is a surrogate else false.
-   */
-  inline bool isSurrogate(uint16_t c) {
-    return 0XD800 <= c && c <= 0XDFFF;
-  }
-   /** Check for UTF-16 high surrogate.
-   * \param[in] c UTF-16 unit..
-   * \return true if c is a high surrogate else false.
-   */
-  inline bool isHighSurrogate(uint16_t c) {
-    return 0XD800 <= c && c <= 0XDBFF;
-  }
-   /** Check for UTF-16 low surrogate.
-   * \param[in] c UTF-16 unit..
-   * \return true if c is a low surrogate else false.
-   */
-  inline bool isLowSurrogate(uint16_t c) {
-    return 0XDC00 <= c && c <= 0XDFFF;
-  }
-  /** Convert UFT-16 surrogate pair to code point.
-   * \param[in] hs high surrogate.
-   * \param[in] ls low surrogate.
-   * \return code point.
-   */
-  inline uint32_t u16ToCp(uint16_t hs, uint16_t ls) {
-    return 0X10000 + (((hs & 0X3FF) << 10) | (ls & 0X3FF));
-  }
-  /** Encodes a 32 bit code point as a UTF-8 sequence.
-   * \param[in] cp code point to encode.
-   * \param[out] str location for UTF-8 sequence.
-   * \param[in] end location following last character of str.
-   * \return location one beyond last encoded character.
-   */
-  char* cpToMb(uint32_t cp, char* str, char* end);
-  /** Get next code point from a UTF-8 sequence.
-   * \param[in] str location for UTF-8 sequence.
-   * \param[in] end location following last character of str.
-   *            May be nullptr if str is zero terminated.
-   * \param[out] rtn location for the code point.
-   * \return location of next UTF-8 character in str of nullptr for error.
-   */
-  const char* mbToCp(const char* str, const char* end, uint32_t* rtn);
-  /** Get next code point from a UTF-8 sequence as UTF-16.
-   * \param[in] str location for UTF-8 sequence.
-   * \param[in] end location following last character of str.
-   * \param[out] hs location for the code point or high surrogate.
-   * \param[out] ls location for zero or high surrogate.
-   * \return location of next UTF-8 character in str of nullptr for error.
-   */
-  const char* mbToU16(const char* str,
-                      const char* end, uint16_t* hs, uint16_t* ls);
-}  // namespace FsUtf
-#endif  // FsUtf_h

lib/SdFat_NoArduino/src/common/PartitionTable.cpp

@@ -1,103 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * 
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include "PartitionTable.h"
-#include "DebugMacros.h"
-#include "FsStructs.h"
-
-// Read MBR format partition table, retrieve the start sector number of a volume
-static uint32_t partitionTableGetVolumeStartSectorMBR(FsCache& fscache, uint8_t part)
-{
-  if (part <= 0 || part > 4) {
-    DBG_FAIL_MACRO;
-    return 0;
-  }
-
-  const uint8_t *sector = fscache.prepare(0, FsCache::CACHE_FOR_READ);
-  const MbrSector_t *mbr = reinterpret_cast<const MbrSector_t*>(sector);
-  if (!mbr) {
-    DBG_FAIL_MACRO;
-    return 0;
-  }
-  
-  const MbrPart_t *mp = mbr->part + part - 1;
-  if (mp->type == 0 || getLe32(mp->totalSectors) == 0) {
-    DBG_FAIL_MACRO;
-    return 0;
-  }
-
-  return getLe32(mp->relativeSectors);
-}
-
-// Read GPT format partition table, retrieve the start sector number of a volume
-static uint32_t partitionTableGetVolumeStartSectorGPT(FsCache& fscache, uint8_t part)
-{
-  if (part <= 0 || part > 4) {
-    DBG_FAIL_MACRO;
-    return 0;
-  }
-
-  const uint8_t *sector = fscache.prepare(1, FsCache::CACHE_FOR_READ);
-  const GPT_Header_t *gpt = reinterpret_cast<const GPT_Header_t*>(sector);
-
-  if (getLe64(gpt->signature) != 0x5452415020494645ULL) {
-    DBG_FAIL_MACRO;
-    return 0;
-  }
-
-  // First 4 partition table entries are in LBA 2
-  sector = fscache.prepare(2, FsCache::CACHE_FOR_READ);
-  const GPT_PartitionEntry_t *partentry =
-    reinterpret_cast<const GPT_PartitionEntry_t*>(sector + 128 * (part - 1));
-
-  uint64_t startSector = getLe64(partentry->first_lba);
-  uint32_t startSector32 = static_cast<uint32_t>(startSector);
-  if (startSector32 != startSector)
-  {
-    // Currently limited to 2^32 sectors = 2 TB by other parts of SdFat code.
-    DBG_FAIL_MACRO;
-    return 0;
-  }
-
-  return startSector32;
-}
-
-uint32_t partitionTableGetVolumeStartSector(FsCache& fscache, uint8_t part)
-{
-  uint32_t start;
-  
-  // Check for GPT partition table first, because it has clearly identifiable
-  // signature. It is also common for GPT-partitioned drives to have MBR-style
-  // fallback boot record at the start.
-  start = partitionTableGetVolumeStartSectorGPT(fscache, part);
-
-  if (start == 0)
-  {
-    start = partitionTableGetVolumeStartSectorMBR(fscache, part);
-  }
-
-  return start;
-}

lib/SdFat_NoArduino/src/common/PartitionTable.h

@@ -1,40 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * 
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef PartitionTable_h
-#define PartitionTable_h
-
-#include "FsCache.h"
-
-/**
- * Parse either MBR or GPT format partition table to get the first sector
- * number of a volume.
- * \param[in] fscache Cache instance used to read the disk.
- * \param[in] part Index of partition to read, 1 to 4.
- * \return First sector of volume, or 0 if partition table could not be parsed.
- */
-uint32_t partitionTableGetVolumeStartSector(FsCache& fscache, uint8_t part);
-
-#endif

lib/SdFat_NoArduino/src/common/SysCall.h

@@ -1,62 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/**
- * \file
- * \brief SysCall class
- */
-#ifndef SysCall_h
-#define SysCall_h
-#include <stdint.h>
-#include <stddef.h>
-#include "../SdFatConfig.h"
-#if __cplusplus < 201103
-#warning nullptr defined
-/** Define nullptr if not C++11 */
-#define nullptr NULL
-#endif  // __cplusplus < 201103
-//------------------------------------------------------------------------------
-#if ENABLE_ARDUINO_FEATURES
-#if defined(ARDUINO)
-/** Use Arduino Print. */
-typedef Print print_t;
-/** Use Arduino Stream. */
-typedef Stream stream_t;
-#else  // defined(ARDUINO)
-#error "Unknown system"
-#endif  // defined(ARDUINO)
-//------------------------------------------------------------------------------
-#ifndef F
-/** Define macro for strings stored in flash. */
-#define F(str) (str)
-#endif  // F
-//------------------------------------------------------------------------------
-#else  // ENABLE_ARDUINO_FEATURES
-#include "PrintBasic.h"
-/** If not Arduino */
-typedef PrintBasic print_t;
-/** If not Arduino */
-typedef PrintBasic stream_t;
-#endif  // ENABLE_ARDUINO_FEATURES
-#endif  // SysCall_h

lib/SdFat_NoArduino/src/common/upcase.cpp

@@ -1,228 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include <stddef.h>
-#include "upcase.h"
-#ifdef __AVR__
-#include <avr/pgmspace.h>
-#define TABLE_MEM PROGMEM
-#define readTable8(sym)  pgm_read_byte(&sym)
-#define readTable16(sym) pgm_read_word(&sym)
-#else  // __AVR__
-#define TABLE_MEM
-#define readTable8(sym)  (sym)
-#define readTable16(sym) (sym)
-#endif  // __AVR__
-
-struct map16 {
-  uint16_t base;
-  int8_t off;
-  uint8_t count;
-};
-typedef struct map16 map16_t;
-
-struct pair16 {
-  uint16_t key;
-  uint16_t val;
-};
-typedef struct pair16 pair16_t;
-//------------------------------------------------------------------------------
-static const map16_t mapTable[] TABLE_MEM = {
-  {0X0061, -32,  26},
-  {0X00E0, -32,  23},
-  {0X00F8, -32,  7 },
-  {0X0100,   1,  48},
-  {0X0132,   1,   6},
-  {0X0139,   1,  16},
-  {0X014A,   1,  46},
-  {0X0179,   1,   6},
-  {0X0182,   1,   4},
-  {0X01A0,   1,   6},
-  {0X01B3,   1,   4},
-  {0X01CD,   1,  16},
-  {0X01DE,   1,  18},
-  {0X01F8,   1,  40},
-  {0X0222,   1,  18},
-  {0X0246,   1,  10},
-  {0X03AD, -37,   3},
-  {0X03B1, -32,  17},
-  {0X03C3, -32,   9},
-  {0X03D8,   1,  24},
-  {0X0430, -32,  32},
-  {0X0450, -80,  16},
-  {0X0460,   1,  34},
-  {0X048A,   1,  54},
-  {0X04C1,   1,  14},
-  {0X04D0,   1,  68},
-  {0X0561, -48,  38},
-  {0X1E00,   1, 150},
-  {0X1EA0,   1,  90},
-  {0X1F00,   8,   8},
-  {0X1F10,   8,   6},
-  {0X1F20,   8,   8},
-  {0X1F30,   8,   8},
-  {0X1F40,   8,   6},
-  {0X1F60,   8,   8},
-  {0X1F70,  74,   2},
-  {0X1F72,  86,   4},
-  {0X1F76, 100,   2},
-  {0X1F7A, 112,   2},
-  {0X1F7C, 126,   2},
-  {0X1F80,   8,   8},
-  {0X1F90,   8,   8},
-  {0X1FA0,   8,   8},
-  {0X1FB0,   8,   2},
-  {0X1FD0,   8,   2},
-  {0X1FE0,   8,   2},
-  {0X2170, -16,  16},
-  {0X24D0, -26,  26},
-  {0X2C30, -48,  47},
-  {0X2C67,   1,   6},
-  {0X2C80,   1, 100},
-  {0X2D00,   0,  38},
-  {0XFF41, -32,  26},
-};
-const size_t MAP_DIM = sizeof(mapTable)/sizeof(map16_t);
-//------------------------------------------------------------------------------
-static const pair16_t lookupTable[] TABLE_MEM = {
-  {0X00FF, 0X0178},
-  {0X0180, 0X0243},
-  {0X0188, 0X0187},
-  {0X018C, 0X018B},
-  {0X0192, 0X0191},
-  {0X0195, 0X01F6},
-  {0X0199, 0X0198},
-  {0X019A, 0X023D},
-  {0X019E, 0X0220},
-  {0X01A8, 0X01A7},
-  {0X01AD, 0X01AC},
-  {0X01B0, 0X01AF},
-  {0X01B9, 0X01B8},
-  {0X01BD, 0X01BC},
-  {0X01BF, 0X01F7},
-  {0X01C6, 0X01C4},
-  {0X01C9, 0X01C7},
-  {0X01CC, 0X01CA},
-  {0X01DD, 0X018E},
-  {0X01F3, 0X01F1},
-  {0X01F5, 0X01F4},
-  {0X023A, 0X2C65},
-  {0X023C, 0X023B},
-  {0X023E, 0X2C66},
-  {0X0242, 0X0241},
-  {0X0253, 0X0181},
-  {0X0254, 0X0186},
-  {0X0256, 0X0189},
-  {0X0257, 0X018A},
-  {0X0259, 0X018F},
-  {0X025B, 0X0190},
-  {0X0260, 0X0193},
-  {0X0263, 0X0194},
-  {0X0268, 0X0197},
-  {0X0269, 0X0196},
-  {0X026B, 0X2C62},
-  {0X026F, 0X019C},
-  {0X0272, 0X019D},
-  {0X0275, 0X019F},
-  {0X027D, 0X2C64},
-  {0X0280, 0X01A6},
-  {0X0283, 0X01A9},
-  {0X0288, 0X01AE},
-  {0X0289, 0X0244},
-  {0X028A, 0X01B1},
-  {0X028B, 0X01B2},
-  {0X028C, 0X0245},
-  {0X0292, 0X01B7},
-  {0X037B, 0X03FD},
-  {0X037C, 0X03FE},
-  {0X037D, 0X03FF},
-  {0X03AC, 0X0386},
-  {0X03C2, 0X03A3},
-  {0X03CC, 0X038C},
-  {0X03CD, 0X038E},
-  {0X03CE, 0X038F},
-  {0X03F2, 0X03F9},
-  {0X03F8, 0X03F7},
-  {0X03FB, 0X03FA},
-  {0X04CF, 0X04C0},
-  {0X1D7D, 0X2C63},
-  {0X1F51, 0X1F59},
-  {0X1F53, 0X1F5B},
-  {0X1F55, 0X1F5D},
-  {0X1F57, 0X1F5F},
-  {0X1F78, 0X1FF8},
-  {0X1F79, 0X1FF9},
-  {0X1FB3, 0X1FBC},
-  {0X1FCC, 0X1FC3},
-  {0X1FE5, 0X1FEC},
-  {0X1FFC, 0X1FF3},
-  {0X214E, 0X2132},
-  {0X2184, 0X2183},
-  {0X2C61, 0X2C60},
-  {0X2C76, 0X2C75},
-};
-const size_t LOOKUP_DIM = sizeof(lookupTable)/sizeof(pair16_t);
-//------------------------------------------------------------------------------
-static size_t searchPair16(const pair16_t* table, size_t size, uint16_t key) {
-  size_t left = 0;
-  size_t right = size;
-  size_t mid;
-  while (right - left > 1) {
-    mid = left + (right - left)/2;
-    if (readTable16(table[mid].key) <= key) {
-      left = mid;
-    } else {
-      right = mid;
-    }
-  }
-  return left;
-}
-//------------------------------------------------------------------------------
-uint16_t toUpcase(uint16_t chr) {
-  uint16_t i, first;
-  // Optimize for simple ASCII.
-  if (chr < 127) {
-    return chr - ('a' <= chr && chr <= 'z' ? 'a' - 'A' : 0);
-  }
-  i = searchPair16(reinterpret_cast<const pair16_t*>(mapTable), MAP_DIM, chr);
-  first = readTable16(mapTable[i].base);
-  if (first <= chr && (chr - first)  < readTable8(mapTable[i].count)) {
-    int8_t off = readTable8(mapTable[i].off);
-    if (off == 1) {
-      return chr - ((chr - first) & 1);
-    }
-    return chr + (off ? off : -0x1C60);
-  }
-  i = searchPair16(lookupTable, LOOKUP_DIM, chr);
-  if (readTable16(lookupTable[i].key) == chr) {
-    return readTable16(lookupTable[i].val);
-  }
-  return chr;
-}
-//------------------------------------------------------------------------------
-uint32_t upcaseChecksum(uint16_t uc, uint32_t sum) {
-  sum = (sum << 31) + (sum >> 1) + (uc & 0XFF);
-  sum = (sum << 31) + (sum >> 1) + (uc >> 8);
-  return sum;
-}

lib/SdFat_NoArduino/src/common/upcase.h

@@ -1,30 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef upcase_h
-#define upcase_h
-#include <stdint.h>
-uint16_t toUpcase(uint16_t chr);
-uint32_t upcaseChecksum(uint16_t unicode, uint32_t checksum);
-#endif  // upcase_h

lib/SdFat_NoArduino/src/iostream/ArduinoStream.h

@@ -1,150 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef ArduinoStream_h
-#define ArduinoStream_h
-/**
- * \file
- * \brief ArduinoInStream and ArduinoOutStream classes
- */
-#include "bufstream.h"
-//==============================================================================
-/**
- * \class ArduinoInStream
- * \brief Input stream for Arduino Stream objects
- */
-class ArduinoInStream : public ibufstream {
- public:
-  /**
-   * Constructor
-   * \param[in] hws hardware stream
-   * \param[in] buf buffer for input line
-   * \param[in] size size of input buffer
-   */
-  ArduinoInStream(Stream &hws, char* buf, size_t size) {
-    m_hw = &hws;
-    m_line = buf;
-    m_size = size;
-  }
-  /** read a line. */
-  void readline() {
-    size_t i = 0;
-    uint32_t t;
-    m_line[0] = '\0';
-    while (!m_hw->available()) {
-      yield();
-    }
-
-    while (1) {
-      t = millis();
-      while (!m_hw->available()) {
-        if ((millis() - t) > 10) {
-          goto done;
-        }
-      }
-      if (i >= (m_size - 1)) {
-        setstate(failbit);
-        return;
-      }
-      m_line[i++] = m_hw->read();
-      m_line[i] = '\0';
-    }
-done:
-    init(m_line);
-  }
-
- protected:
-  /** Internal - do not use.
-   * \param[in] off
-   * \param[in] way
-   * \return true/false.
-   */
-  bool seekoff(off_type off, seekdir way) {
-    (void)off;
-    (void)way;
-    return false;
-  }
-  /** Internal - do not use.
-   * \param[in] pos
-   * \return true/false.
-   */
-  bool seekpos(pos_type pos) {
-    (void)pos;
-    return false;
-  }
-
- private:
-  char *m_line;
-  size_t m_size;
-  Stream* m_hw;
-};
-//==============================================================================
-/**
- * \class ArduinoOutStream
- * \brief Output stream for Arduino Print objects
- */
-class ArduinoOutStream : public ostream {
- public:
-  /** constructor
-   *
-   * \param[in] pr Print object for this ArduinoOutStream.
-   */
-  explicit ArduinoOutStream(print_t& pr) : m_pr(&pr) {}
-
- protected:
-  /// @cond SHOW_PROTECTED
-  /**
-   * Internal do not use
-   * \param[in] c
-   */
-  void putch(char c) {
-    if (c == '\n') {
-      m_pr->write('\r');
-    }
-    m_pr->write(c);
-  }
-  void putstr(const char* str) {
-    m_pr->write(str);
-  }
-  bool seekoff(off_type off, seekdir way) {
-    (void)off;
-    (void)way;
-    return false;
-  }
-  bool seekpos(pos_type pos) {
-    (void)pos;
-    return false;
-  }
-  bool sync() {
-    return true;
-  }
-  pos_type tellpos() {
-    return 0;
-  }
-  /// @endcond
- private:
-  ArduinoOutStream() {}
-  print_t* m_pr;
-};
-#endif  // ArduinoStream_h

lib/SdFat_NoArduino/src/iostream/StdioStream.cpp

@@ -1,451 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "StdioStream.h"
-#include "../common/FmtNumber.h"
-//------------------------------------------------------------------------------
-int StdioStream::fclose() {
-  int rtn = 0;
-  if (!m_status) {
-    return EOF;
-  }
-  if (m_status & S_SWR) {
-    if (!flushBuf()) {
-      rtn = EOF;
-    }
-  }
-  if (!StreamBaseFile::close()) {
-    rtn = EOF;
-  }
-  m_r = 0;
-  m_w = 0;
-  m_status = 0;
-  return rtn;
-}
-//------------------------------------------------------------------------------
-int StdioStream::fflush() {
-  if ((m_status & (S_SWR | S_SRW)) && !(m_status & S_SRD)) {
-    if (flushBuf() && StreamBaseFile::sync()) {
-      return 0;
-    }
-  }
-  return EOF;
-}
-//------------------------------------------------------------------------------
-char* StdioStream::fgets(char* str, size_t num, size_t* len) {
-  char* s = str;
-  size_t n;
-  if (num-- == 0) {
-    return 0;
-  }
-  while (num) {
-    if ((n = m_r) == 0) {
-      if (!fillBuf()) {
-        if (s == str) {
-          return 0;
-        }
-        break;
-      }
-      n = m_r;
-    }
-    if (n > num) {
-      n = num;
-    }
-    uint8_t* end = reinterpret_cast<uint8_t*>(memchr(m_p, '\n', n));
-    if (end != 0) {
-      n = ++end - m_p;
-      memcpy(s, m_p, n);
-      m_r -= n;
-      m_p = end;
-      s += n;
-      break;
-    }
-    memcpy(s, m_p, n);
-    m_r -= n;
-    m_p += n;
-    s += n;
-    num -= n;
-  }
-  *s = 0;
-  if (len) {
-    *len = s - str;
-  }
-  return str;
-}
-//------------------------------------------------------------------------------
-bool StdioStream::fopen(const char* path, const char* mode) {
-  oflag_t oflag;
-  uint8_t m;
-  switch (*mode++) {
-  case 'a':
-    m = O_WRONLY;
-    oflag = O_CREAT | O_APPEND;
-    m_status = S_SWR;
-    break;
-
-  case 'r':
-    m = O_RDONLY;
-    oflag = 0;
-    m_status = S_SRD;
-    break;
-
-  case 'w':
-    m = O_WRONLY;
-    oflag = O_CREAT | O_TRUNC;
-    m_status = S_SWR;
-    break;
-
-  default:
-    goto fail;
-  }
-  while (*mode) {
-    switch (*mode++) {
-    case '+':
-      m_status = S_SRW;
-      m = O_RDWR;
-      break;
-
-    case 'b':
-      break;
-
-    case 'x':
-      oflag |= O_EXCL;
-      break;
-
-    default:
-      goto fail;
-    }
-  }
-  oflag |= m;
-  if (!StreamBaseFile::open(path, oflag)) {
-    goto fail;
-  }
-  m_r = 0;
-  m_w = 0;
-  m_p = m_buf;
-  return true;
-
- fail:
-  m_status = 0;
-  return false;
-}
-//------------------------------------------------------------------------------
-int StdioStream::fputs(const char* str) {
-  size_t len = strlen(str);
-  return fwrite(str, 1, len) == len ? len : EOF;
-}
-//------------------------------------------------------------------------------
-size_t StdioStream::fread(void* ptr, size_t size, size_t count) {
-  uint8_t* dst = reinterpret_cast<uint8_t*>(ptr);
-  size_t total = size*count;
-  if (total == 0) {
-    return 0;
-  }
-  size_t need = total;
-  while (need > m_r) {
-    memcpy(dst, m_p, m_r);
-    dst += m_r;
-    m_p += m_r;
-    need -= m_r;
-    if (!fillBuf()) {
-      return (total - need)/size;
-    }
-  }
-  memcpy(dst, m_p, need);
-  m_r -= need;
-  m_p += need;
-  return count;
-}
-//------------------------------------------------------------------------------
-int StdioStream::fseek(int32_t offset, int origin) {
-  int32_t pos;
-  if (m_status & S_SWR) {
-    if (!flushBuf()) {
-      goto fail;
-    }
-  }
-  switch (origin) {
-  case SEEK_CUR:
-    pos = ftell();
-    if (pos < 0) {
-      goto fail;
-    }
-    pos += offset;
-    if (!StreamBaseFile::seekCur(pos)) {
-      goto fail;
-    }
-    break;
-
-  case SEEK_SET:
-    if (!StreamBaseFile::seekSet(offset)) {
-      goto fail;
-    }
-    break;
-
-  case SEEK_END:
-    if (!StreamBaseFile::seekEnd(offset)) {
-      goto fail;
-    }
-    break;
-
-  default:
-    goto fail;
-  }
-  m_r = 0;
-  m_p = m_buf;
-  return 0;
-
- fail:
-  return EOF;
-}
-//------------------------------------------------------------------------------
-int32_t StdioStream::ftell() {
-  uint32_t pos = StreamBaseFile::curPosition();
-  if (m_status & S_SRD) {
-    if (m_r > pos) {
-      return -1L;
-    }
-    pos -= m_r;
-  } else if (m_status & S_SWR) {
-    pos += m_p - m_buf;
-  }
-  return pos;
-}
-//------------------------------------------------------------------------------
-size_t StdioStream::fwrite(const void* ptr, size_t size, size_t count) {
-  return write(ptr, count*size) < 0 ? EOF : count;
-}
-//------------------------------------------------------------------------------
-int StdioStream::write(const void* buf, size_t count) {
-  const uint8_t* src = static_cast<const uint8_t*>(buf);
-  size_t todo = count;
-
-  while (todo > m_w) {
-    memcpy(m_p, src, m_w);
-    m_p += m_w;
-    src += m_w;
-    todo -= m_w;
-    if (!flushBuf()) {
-      return EOF;
-    }
-  }
-  memcpy(m_p, src, todo);
-  m_p += todo;
-  m_w -= todo;
-  return count;
-}
-//------------------------------------------------------------------------------
-#if (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
-size_t StdioStream::print(const __FlashStringHelper *str) {
-  const char *p = (const char*)str;
-  uint8_t c;
-  while ((c = pgm_read_byte(p))) {
-    if (putc(c) < 0) {
-      return 0;
-    }
-    p++;
-  }
-  return p - (const char*)str;
-}
-#endif  // (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
-//------------------------------------------------------------------------------
-int StdioStream::printDec(float value, uint8_t prec) {
-  char buf[24];
-  char *ptr = fmtDouble(buf + sizeof(buf), value, prec, false);
-  return write(ptr, buf + sizeof(buf) - ptr);
-}
-//------------------------------------------------------------------------------
-int StdioStream::printDec(signed char n) {
-  if (n < 0) {
-    if (fputc('-') < 0) {
-      return -1;
-    }
-    n = -n;
-  }
-  return printDec((unsigned char)n);
-}
-//------------------------------------------------------------------------------
-int StdioStream::printDec(int16_t n) {
-  int s;
-  uint8_t rtn = 0;
-  if (n < 0) {
-    if (fputc('-') < 0) {
-      return -1;
-    }
-    n = -n;
-    rtn++;
-  }
-  if ((s = printDec((uint16_t)n)) < 0) {
-    return s;
-  }
-  return rtn;
-}
-//------------------------------------------------------------------------------
-int StdioStream::printDec(uint16_t n) {
-  char buf[5];
-  char *ptr = fmtBase10(buf + sizeof(buf), n);
-  uint8_t len = buf + sizeof(buf) - ptr;
-  return write(ptr, len);
-}
-//------------------------------------------------------------------------------
-int StdioStream::printDec(int32_t n) {
-  uint8_t s = 0;
-  if (n < 0) {
-    if (fputc('-') < 0) {
-      return -1;
-    }
-    n = -n;
-    s = 1;
-  }
-  int rtn = printDec((uint32_t)n);
-  return rtn > 0 ? rtn + s : -1;
-}
-//------------------------------------------------------------------------------
-int StdioStream::printDec(uint32_t n) {
-  char buf[10];
-  char *ptr = fmtBase10(buf + sizeof(buf), n);
-  uint8_t len = buf + sizeof(buf) - ptr;
-  return write(ptr, len);
-}
-//------------------------------------------------------------------------------
-int StdioStream::printHex(uint32_t n) {
-  char buf[8];
-  char *ptr = fmtHex(buf + sizeof(buf), n);
-  uint8_t len = buf + sizeof(buf) - ptr;
-  return write(ptr, len);
-}
-//------------------------------------------------------------------------------
-bool StdioStream::rewind() {
-  if (m_status & S_SWR) {
-    if (!flushBuf()) {
-      return false;
-    }
-  }
-  StreamBaseFile::seekSet(0);
-  m_r = 0;
-  return true;
-}
-//------------------------------------------------------------------------------
-int StdioStream::ungetc(int c) {
-  // error if EOF.
-  if (c == EOF) {
-    return EOF;
-  }
-  // error if not reading.
-  if ((m_status & S_SRD) == 0) {
-    return EOF;
-  }
-  // error if no space.
-  if (m_p == m_buf) {
-    return EOF;
-  }
-  m_r++;
-  m_status &= ~S_EOF;
-  return *--m_p = (uint8_t)c;
-}
-//==============================================================================
-// private
-//------------------------------------------------------------------------------
-int StdioStream::fillGet() {
-  if (!fillBuf()) {
-    return EOF;
-  }
-  m_r--;
-  return *m_p++;
-}
-//------------------------------------------------------------------------------
-// private
-bool StdioStream::fillBuf() {
-  if (!(m_status &
-        S_SRD)) {  // check for S_ERR and S_EOF ??/////////////////
-    if (!(m_status & S_SRW)) {
-      m_status |= S_ERR;
-      return false;
-    }
-    if (m_status & S_SWR) {
-      if (!flushBuf()) {
-        return false;
-      }
-      m_status &= ~S_SWR;
-      m_status |= S_SRD;
-      m_w = 0;
-    }
-  }
-  m_p = m_buf + UNGETC_BUF_SIZE;
-  int nr = StreamBaseFile::read(m_p, sizeof(m_buf) - UNGETC_BUF_SIZE);
-  if (nr <= 0) {
-    m_status |= nr < 0 ? S_ERR : S_EOF;
-    m_r = 0;
-    return false;
-  }
-  m_r = nr;
-  return true;
-}
-//------------------------------------------------------------------------------
-// private
-bool StdioStream::flushBuf() {
-  if (!(m_status &
-        S_SWR)) {  // check for S_ERR ??////////////////////////
-    if (!(m_status & S_SRW)) {
-      m_status |= S_ERR;
-      return false;
-    }
-    m_status &= ~S_SRD;
-    m_status |= S_SWR;
-    m_r = 0;
-    m_w = sizeof(m_buf);
-    m_p = m_buf;
-    return true;
-  }
-  uint8_t n = m_p - m_buf;
-  m_p = m_buf;
-  m_w = sizeof(m_buf);
-  if (StreamBaseFile::write(m_buf, n) == n) {
-    return true;
-  }
-  m_status |= S_ERR;
-  return false;
-}
-//------------------------------------------------------------------------------
-int StdioStream::flushPut(uint8_t c) {
-  if (!flushBuf()) {
-    return EOF;
-  }
-  m_w--;
-  return *m_p++ = c;
-}
-//------------------------------------------------------------------------------
-char* StdioStream::fmtSpace(uint8_t len) {
-  if (m_w < len) {
-    if (!flushBuf() || m_w < len) {
-      return 0;
-    }
-  }
-  if (len > m_w) {
-    return 0;
-  }
-  m_p += len;
-  m_w -= len;
-  return reinterpret_cast<char*>(m_p);
-}

lib/SdFat_NoArduino/src/iostream/StdioStream.h

@@ -1,663 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef StdioStream_h
-#define StdioStream_h
-/**
- * \file
- * \brief StdioStream class
- */
-#include <limits.h>
-#include "ios.h"
-//------------------------------------------------------------------------------
-/** Total size of stream buffer. The entire buffer is used for output.
-  * During input UNGETC_BUF_SIZE of this space is reserved for ungetc.
-  */
-const uint8_t STREAM_BUF_SIZE = 64;
-/** Amount of buffer allocated for ungetc during input. */
-const uint8_t UNGETC_BUF_SIZE = 2;
-//------------------------------------------------------------------------------
-// Get rid of any macros defined in <stdio.h>.
-#include <stdio.h>
-#undef clearerr
-#undef fclose
-#undef feof
-#undef ferror
-#undef fflush
-#undef fgetc
-#undef fgetpos
-#undef fgets
-#undef fopen
-#undef fprintf
-#undef fputc
-#undef fputs
-#undef fread
-#undef freopen
-#undef fscanf
-#undef fseek
-#undef fsetpos
-#undef ftell
-#undef fwrite
-#undef getc
-#undef getchar
-#undef gets
-#undef perror
-//#undef printf  // NOLINT
-#undef putc
-#undef putchar
-#undef puts
-#undef remove
-#undef rename
-#undef rewind
-#undef scanf
-#undef setbuf
-#undef setvbuf
-//#undef sprintf  // NOLINT
-#undef sscanf
-#undef tmpfile
-#undef tmpnam
-#undef ungetc
-#undef vfprintf
-#undef vprintf
-#undef vsprintf
-
-// make sure needed macros are defined
-#ifndef EOF
-/** End-of-file return value. */
-#define EOF (-1)
-#endif  // EOF
-#ifndef NULL
-/** Null pointer */
-#define NULL 0
-#endif  // NULL
-#ifndef SEEK_CUR
-/** Seek relative to current position. */
-#define SEEK_CUR 1
-#endif  // SEEK_CUR
-#ifndef SEEK_END
-/** Seek relative to end-of-file. */
-#define SEEK_END 2
-#endif  // SEEK_END
-#ifndef SEEK_SET
-/** Seek relative to start-of-file. */
-#define SEEK_SET 0
-#endif  // SEEK_SET
-//------------------------------------------------------------------------------
-/** \class StdioStream
- * \brief StdioStream implements a minimal stdio stream.
- *
- * StdioStream does not support subdirectories or long file names.
- */
-class StdioStream : private StreamBaseFile {
- public:
-  /** Constructor
-   *
-   */
-  StdioStream() {}
-  //----------------------------------------------------------------------------
-  /** Clear the stream's end-of-file and error indicators. */
-  void clearerr() {
-    m_status &= ~(S_ERR | S_EOF);
-  }
-  //----------------------------------------------------------------------------
-  /** Close a stream.
-   *
-   * A successful call to the fclose function causes the stream  to be
-   * flushed and the associated file to be closed. Any unwritten buffered
-   * data is written to the file; any unread buffered data is discarded.
-   * Whether or not the call succeeds, the stream is disassociated from
-   * the file.
-   *
-   * \return zero if the stream was successfully closed, or EOF if any any
-   * errors are detected.
-   */
-  int fclose();
-  //----------------------------------------------------------------------------
-  /** Test the stream's end-of-file indicator.
-   * \return non-zero if and only if the end-of-file indicator is set.
-   */
-  int feof() {
-    return (m_status & S_EOF) != 0;
-  }
-  //----------------------------------------------------------------------------
-  /** Test the stream's error indicator.
-   * \return return non-zero if and only if the error indicator is set.
-   */
-  int ferror() {
-    return (m_status & S_ERR) != 0;
-  }
-  //----------------------------------------------------------------------------
-  /** Flush the stream.
-   *
-   * If stream is an output stream or an update stream in which the most
-   * recent operation was not input, any unwritten data is written to the
-   * file; otherwise the call is an error since any buffered input data
-   * would be lost.
-   *
-   * \return sets the error indicator for the stream and returns EOF if an
-   * error occurs, otherwise it returns zero.
-   */
-  int fflush();
-  //----------------------------------------------------------------------------
-  /** Get a byte from the stream.
-   *
-   * \return If the end-of-file indicator for the stream is set, or if the
-   * stream is at end-of-file, the end-of-file indicator for the stream is
-   * set and the fgetc function returns EOF. Otherwise, the fgetc function
-   * returns the next character from the input stream.
-   */
-  int fgetc() {
-    return m_r-- == 0 ? fillGet() : *m_p++;
-  }
-  //----------------------------------------------------------------------------
-  /** Get a string from a stream.
-   *
-   * The fgets function reads at most one less than the number of
-   * characters specified by num from the stream into the array pointed
-   * to by str. No additional characters are read after a new-line
-   * character (which is retained) or after end-of-file. A null character
-   * is written immediately after the last character read into the array.
-   *
-   * \param[out] str Pointer to an array of where the string is copied.
-   *
-   * \param[in] num Maximum number of characters including the null
-   * character.
-   *
-   * \param[out] len If len is not null and fgets is successful, the
-   * length of the string is returned.
-   *
-   * \return str if successful. If end-of-file is encountered and no
-   * characters have been read into the array, the contents of the array
-   * remain unchanged and a null pointer is returned. If a read error
-   * occurs during the operation, the array contents are indeterminate
-   * and a null pointer is returned.
-   */
-  char* fgets(char* str, size_t num, size_t* len = 0);
-  //----------------------------------------------------------------------------
-  /** Open a stream.
-   *
-   * Open a file and associates the stream with it.
-   *
-   * \param[in] path file to be opened.
-   *
-   * \param[in] mode a string that indicates the open mode.
-   *
-   * <table>
-   * <tr>
-   * <td>"r" or "rb"</td>
-   * <td>Open a file for reading. The file must exist.</td>
-   * </tr>
-   * <tr>
-   * <td>"w" or "wb"</td>
-   * <td>Truncate an existing to zero length or create an empty file
-   * for writing.</td>
-   * </tr>
-   * <tr>
-   * <td>"wx" or "wbx"</td>
-   * <td>Create a file for writing. Fails if the file already exists.</td>
-   * </tr>
-   * <tr>
-   * <td>"a" or "ab"</td>
-   * <td>Append; open or create file for writing at end-of-file.</td>
-   * </tr>
-   * <tr>
-   * <td>"r+" or "rb+" or "r+b"</td>
-   * <td>Open a file for update (reading and writing).</td>
-   * </tr>
-   * <tr>
-   * <td>"w+" or "w+b" or "wb+"</td>
-   * <td>Truncate an existing to zero length or create a file for update.</td>
-   * </tr>
-   * <tr>
-   * <td>"w+x" or "w+bx" or "wb+x"</td>
-   * <td>Create a file for update. Fails if the file already exists.</td>
-   * </tr>
-   * <tr>
-   * <td>"a+" or "a+b" or "ab+"</td>
-   * <td>Append; open or create a file for update, writing at end-of-file.</td>
-   * </tr>
-   * </table>
-   * The character 'b' shall have no effect, but is allowed for ISO C
-   * standard conformance.
-   *
-   * Opening a file with append mode causes all subsequent writes to the
-   * file to be forced to the then current end-of-file, regardless of
-   * intervening calls to the fseek function.
-   *
-   * When a file is opened with update mode, both input and output may be
-   * performed on the associated stream. However, output shall not be
-   * directly followed by input without an intervening call to the fflush
-   * function or to a file positioning function (fseek, or rewind), and
-   * input shall not be directly followed by output without an intervening
-   * call to a file positioning function, unless the input operation
-   * encounters end-of-file.
-   *
-   * \return true for success or false for failure.
-   */
-  bool fopen(const char* path, const char* mode);
-  //----------------------------------------------------------------------------
-  /** Write a byte to a stream.
-   *
-   * \param[in] c the byte to be written  (converted to an unsigned char).
-   *
-   * \return Upon successful completion, fputc() returns the value it
-   * has written. Otherwise, it returns EOF and sets the error indicator for
-   * the stream.
-   */
-  int fputc(int c) {
-    return m_w-- == 0 ? flushPut(c) : *m_p++ = c;
-  }
-  //----------------------------------------------------------------------------
-  /** Write a string to a stream.
-   *
-   * \param[in] str a pointer to the string to be written.
-   *
-   * \return for success, fputs() returns a non-negative
-   * number. Otherwise, it returns EOF and sets the error indicator for
-   * the stream.
-   */
-  int fputs(const char* str);
-  //----------------------------------------------------------------------------
-  /** Binary input.
-   *
-   * Reads an array of up to count elements, each one with a size of size
-   * bytes.
-   * \param[out] ptr pointer to area of at least (size*count) bytes where
-   * the data will be stored.
-   *
-   * \param[in] size the size, in bytes, of each element to be read.
-   *
-   * \param[in] count the number of elements to be read.
-   *
-   * \return number of elements successfully read, which may be less than
-   * count if a read error or end-of-file is encountered. If size or count
-   * is zero, fread returns zero and the contents of the array and the
-   * state of the stream remain unchanged.
-   */
-  size_t fread(void* ptr, size_t size, size_t count);
-  //----------------------------------------------------------------------------
-  /** Set the file position for the stream.
-   *
-   * \param[in] offset number of offset from the origin.
-   *
-   * \param[in] origin position used as reference for the offset. It is
-   * specified by one of the following constants.
-   *
-   * SEEK_SET	- Beginning of file.
-   *
-   * SEEK_CUR	- Current position of the file pointer.
-   *
-   * SEEK_END	- End of file.
-   *
-   * \return zero for success. Otherwise, it returns non-zero and sets the
-   * error indicator for the stream.
-   */
-  int fseek(int32_t offset, int origin);
-  //----------------------------------------------------------------------------
-  /** Get the current position in a stream.
-   *
-   * \return If successful, ftell return the current value of the position
-   * indicator. On failure, ftell returns −1L.
-   */
-  int32_t ftell();
-  //----------------------------------------------------------------------------
-  /** Binary output.
-   *
-   * Writes an array of up to count elements, each one with a size of size
-   * bytes.
-   * \param[in] ptr pointer to (size*count) bytes of data to be written.
-   *
-   * \param[in] size the size, in bytes, of each element to be written.
-   *
-   * \param[in] count the number of elements to be written.
-   *
-   * \return number of elements successfully written. if this number is
-   * less than count, an error has occurred.  If size or count is zero,
-   * fwrite returns zero.
-   */
-  size_t fwrite(const void * ptr, size_t size, size_t count);
-  //----------------------------------------------------------------------------
-  /** Get a byte from the stream.
-   *
-   * getc and fgetc are equivalent but getc is in-line so it is faster but
-   * require more flash memory.
-   *
-   * \return If the end-of-file indicator for the stream is set, or if the
-   * stream is at end-of-file, the end-of-file indicator for the stream is
-   * set and the fgetc function returns EOF. Otherwise, the fgetc function
-   * returns the next character from the input stream.
-   */
-  inline __attribute__((always_inline))
-  int getc() {
-    return m_r-- == 0 ? fillGet() : *m_p++;
-  }
-  //----------------------------------------------------------------------------
-  /** Write a byte to a stream.
-   *
-   * putc and fputc are equivalent but putc is in-line so it is faster but
-   * require more flash memory.
-   *
-   * \param[in] c the byte to be written  (converted to an unsigned char).
-   *
-   * \return Upon successful completion, fputc() returns the value it
-   * has written. Otherwise, it returns EOF and sets the error indicator for
-   * the stream.
-   */
-  inline __attribute__((always_inline))
-  int putc(int c) {
-    return m_w-- == 0 ? flushPut(c) : *m_p++ = c;
-  }
-  //----------------------------------------------------------------------------
-  /** Write a CR/LF.
-   *
-   * \return two, the number of bytes written, for success or -1 for failure.
-   */
-  inline __attribute__((always_inline))
-  int putCRLF() {
-    if (m_w < 2) {
-      if (!flushBuf()) {
-        return -1;
-      }
-    }
-    *m_p++ = '\r';
-    *m_p++ = '\n';
-    m_w -= 2;
-    return 2;
-  }
-  //----------------------------------------------------------------------------
-  /** Write a character.
-   * \param[in] c the character to write.
-   * \return the number of bytes written.
-   */
-  size_t print(char c) {
-    return putc(c) < 0 ? 0 : 1;
-  }
-  //----------------------------------------------------------------------------
-  /** Write a string.
-   *
-   * \param[in] str the string to be written.
-   *
-   * \return the number of bytes written.
-   */
-  size_t print(const char* str) {
-    int n = fputs(str);
-    return n < 0 ? 0 : n;
-  }
-  //----------------------------------------------------------------------------
-#if (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
-  /** Print a string stored in flash memory.
-   *
-   * \param[in] str the string to print.
-   *
-   * \return the number of bytes written.
-   */
-  size_t print(const __FlashStringHelper *str);
-#endif  // (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
-  //----------------------------------------------------------------------------
-  /** Print a floating point number.
-   *
-   * \param[in] prec Number of digits after decimal point.
-   *
-   * \param[in] val the number to be printed.
-   *
-   * \return the number of bytes written.
-   */
-  size_t print(double val, uint8_t prec = 2) {
-    return print(static_cast<float>(val), prec);
-  }
-  //----------------------------------------------------------------------------
-  /** Print a floating point number.
-   *
-   * \param[in] prec Number of digits after decimal point.
-   *
-   * \param[in] val the number to be printed.
-   *
-   * \return the number of bytes written.
-   */
-  size_t print(float val, uint8_t prec = 2) {
-    int n = printDec(val, prec);
-    return n > 0 ? n : 0;
-  }
-  //----------------------------------------------------------------------------
-  /** Print a number.
-   *
-   * \param[in] val the number to be printed.
-   *
-   * \return the number of bytes written.
-   */
-  template <typename T>
-  size_t print(T val) {
-    int n = printDec(val);
-    return n > 0 ? n : 0;
-  }
-  //----------------------------------------------------------------------------
-  /** Write a CR/LF.
-   *
-   * \return two, the number of bytes written, for success or zero for failure.
-   */
-  size_t println() {
-    return putCRLF() > 0 ? 2 : 0;
-  }
-  //----------------------------------------------------------------------------
-  /** Print a floating point number followed by CR/LF.
-   *
-   * \param[in] val the number to be printed.
-   *
-   * \param[in] prec Number of digits after decimal point.
-   *
-   * \return the number of bytes written.
-   */
-  size_t println(double val, uint8_t prec = 2) {
-    return println(static_cast<float>(val), prec);
-  }
-  //----------------------------------------------------------------------------
-  /** Print a floating point number followed by CR/LF.
-   *
-   * \param[in] val the number to be printed.
-   *
-   * \param[in] prec Number of digits after decimal point.
-   *
-   * \return the number of bytes written.
-   */
-  size_t println(float val, uint8_t prec = 2) {
-    int n = printDec(val, prec);
-    return n > 0 && putCRLF() > 0 ? n + 2 : 0;
-  }
-  //----------------------------------------------------------------------------
-  /** Print an item followed by CR/LF
-   *
-   * \param[in] val the item to be printed.
-   *
-   * \return the number of bytes written.
-   */
-  template <typename T>
-  size_t println(T val) {
-    int n = print(val);
-    return putCRLF() > 0 ? n + 2 : 0;
-  }
-  //----------------------------------------------------------------------------
-  /** Print a char as a number.
-   * \param[in] n number to be printed.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(char n) {
-    if (CHAR_MIN == 0) {
-      return printDec((unsigned char)n);
-    } else {
-      return printDec((signed char)n);
-    }
-  }
-  //----------------------------------------------------------------------------
-  /** print a signed 8-bit integer
-   * \param[in] n number to be printed.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(signed char n);
-  //----------------------------------------------------------------------------
-  /** Print an unsigned 8-bit number.
-   * \param[in] n number to be print.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(unsigned char n) {
-    return printDec((uint16_t)n);
-  }
-  //----------------------------------------------------------------------------
-  /** Print a int16_t
-   * \param[in] n number to be printed.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(int16_t n);
-  //----------------------------------------------------------------------------
-  /** print a uint16_t.
-   * \param[in] n number to be printed.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(uint16_t n);
-  //----------------------------------------------------------------------------
-  /** Print a signed 32-bit integer.
-   * \param[in] n number to be printed.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(int32_t n);
-  //----------------------------------------------------------------------------
-  /** Write an unsigned 32-bit number.
-   * \param[in] n number to be printed.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(uint32_t n);
-  //----------------------------------------------------------------------------
-  /** Print a double.
-   * \param[in] value The number to be printed.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(double value, uint8_t prec) {
-    return printDec(static_cast<float>(value), prec);
-  }
-  //----------------------------------------------------------------------------
-  /** Print a float.
-   * \param[in] value The number to be printed.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printDec(float value, uint8_t prec);
-  //----------------------------------------------------------------------------
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printField(double value, char term, uint8_t prec = 2) {
-    return printField(static_cast<float>(value), term, prec) > 0;
-  }
-  //----------------------------------------------------------------------------
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.
-   * \param[in] prec Number of digits after decimal point.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printField(float value, char term, uint8_t prec = 2) {
-    int rtn = printDec(value, prec);
-    return rtn < 0 || putc(term) < 0 ? -1 : rtn + 1;
-  }
-  //----------------------------------------------------------------------------
-  /** Print a number followed by a field terminator.
-   * \param[in] value The number to be printed.
-   * \param[in] term The field terminator.
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  template <typename T>
-  int printField(T value, char term) {
-    int rtn = printDec(value);
-    return rtn < 0 || putc(term) < 0 ? -1 : rtn + 1;
-  }
-  //----------------------------------------------------------------------------
-  /** Print HEX
-   * \param[in] n number to be printed as HEX.
-   *
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printHex(uint32_t n);
-  //----------------------------------------------------------------------------
-  /** Print HEX with CRLF
-   * \param[in] n number to be printed as HEX.
-   *
-   * \return The number of bytes written or -1 if an error occurs.
-   */
-  int printHexln(uint32_t n) {
-    int rtn = printHex(n);
-    return  rtn < 0 || putCRLF() != 2 ? -1 : rtn + 2;
-  }
-  //----------------------------------------------------------------------------
-  /** Set position of a stream to the beginning.
-   *
-   * The rewind function sets the file position to the beginning of the
-   * file. It is equivalent to fseek(0L, SEEK_SET) except that the error
-   * indicator for the stream is also cleared.
-   *
-   * \return true for success or false for failure.
-   */
-  bool rewind();
-  //----------------------------------------------------------------------------
-  /** Push a byte back into an input stream.
-   *
-   * \param[in] c the byte (converted to an unsigned char) to be pushed back.
-   *
-   * One character of push-back is guaranteed. If the ungetc function is
-   * called too many times without an intervening read or file positioning
-   * operation on that stream, the operation may fail.
-   *
-   * A successful intervening call to a file positioning function (fseek,
-   * fsetpos, or rewind) discards any pushed-back characters for the stream.
-   *
-   * \return Upon successful completion, ungetc() returns the byte pushed
-   * back after conversion. Otherwise it returns EOF.
-   */
-  int ungetc(int c);
-  //============================================================================
- private:
-  bool fillBuf();
-  int fillGet();
-  bool flushBuf();
-  int flushPut(uint8_t c);
-  char* fmtSpace(uint8_t len);
-  int write(const void* buf, size_t count);
-  //----------------------------------------------------------------------------
-  // S_SRD and S_WR are never simultaneously asserted
-  static const uint8_t S_SRD = 0x01;  // OK to read
-  static const uint8_t S_SWR = 0x02;  // OK to write
-  static const uint8_t S_SRW = 0x04;  // open for reading & writing
-  static const uint8_t S_EOF = 0x10;  // found EOF
-  static const uint8_t S_ERR = 0x20;  // found error
-  //----------------------------------------------------------------------------
-  uint8_t  m_buf[STREAM_BUF_SIZE];
-  uint8_t  m_status = 0;
-  uint8_t* m_p = m_buf;
-  uint8_t  m_r = 0;
-  uint8_t  m_w;
-};
-//------------------------------------------------------------------------------
-#endif  // StdioStream_h

lib/SdFat_NoArduino/src/iostream/StreamBaseClass.cpp

@@ -1,160 +0,0 @@
-/**
- * Copyright (c) 2011-2022 Bill Greiman
- * This file is part of the SdFat library for SD memory cards.
- *
- * MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "fstream.h"
-//------------------------------------------------------------------------------
-int16_t StreamBaseClass::getch() {
-  uint8_t c;
-  int8_t s = StreamBaseFile::read(&c, 1);
-  if (s != 1) {
-    if (s < 0) {
-      setstate(badbit);
-    } else {
-      setstate(eofbit);
-    }
-    return -1;
-  }
-  if (c != '\r' || (getmode() & ios::binary)) {
-    return c;
-  }
-  s = StreamBaseFile::read(&c, 1);
-  if (s == 1 && c == '\n') {
-    return c;
-  }
-  if (s == 1) {
-    StreamBaseFile::seekCur(-1);
-  }
-  return '\r';
-}
-//------------------------------------------------------------------------------
-void StreamBaseClass::open(const char* path, ios::openmode mode) {
-  oflag_t oflag;
-  clearWriteError();
-  switch (mode & (app | in | out | trunc)) {
-  case app | in:
-  case app | in | out:
-    oflag = O_RDWR | O_APPEND | O_CREAT;
-    break;
-
-  case app:
-  case app | out:
-    oflag = O_WRONLY | O_APPEND | O_CREAT;
-    break;
-
-  case in:
-    oflag = O_RDONLY;
-    break;
-
-  case in | out:
-    oflag = O_RDWR | O_CREAT;
-    break;
-
-  case in | out | trunc:
-    oflag = O_RDWR | O_TRUNC | O_CREAT;
-    break;
-
-  case out:
-  case out | trunc:
-    oflag = O_WRONLY | O_TRUNC | O_CREAT;
-    break;
-
-  default:
-    goto fail;
-  }
-  if (mode & ios::ate) {
-    oflag |= O_AT_END;
-  }
-  if (!StreamBaseFile::open(path, oflag)) {
-    goto fail;
-  }
-  setmode(mode);
-  clear();
-  return;
-
- fail:
-  StreamBaseFile::close();
-  setstate(failbit);
-  return;
-}
-//------------------------------------------------------------------------------
-void StreamBaseClass::putch(char c) {
-  if (c == '\n' && !(getmode() & ios::binary)) {
-    write('\r');
-  }
-  write(c);
-  if (getWriteError()) {
-    setstate(badbit);
-  }
-}
-//------------------------------------------------------------------------------
-void StreamBaseClass::putstr(const char* str) {
-  size_t n = 0;
-  while (1) {
-    char c = str[n];
-    if (c == '\0' || (c == '\n' && !(getmode() & ios::binary))) {
-      if (n > 0) {
-        write(str, n);
-      }
-      if (c == '\0') {
-        break;
-      }
-      write('\r');
-      str += n;
-      n = 0;
-    }
-    n++;
-  }
-  if (getWriteError()) {
-    setstate(badbit);
-  }
-}
-//------------------------------------------------------------------------------
-bool StreamBaseClass::seekoff(off_type off, seekdir way) {
-  pos_type pos;
-  switch (way) {
-  case beg:
-    pos = off;
-    break;
-
-  case cur:
-    pos = StreamBaseFile::curPosition() + off;
-    break;
-
-  case end:
-    pos = StreamBaseFile::fileSize() + off;
-    break;
-
-  default:
-    return false;
-  }
-  return seekpos(pos);
-}
-//------------------------------------------------------------------------------
-int StreamBaseClass::write(const void* buf, size_t n) {
-  return StreamBaseFile::write(buf, n);
-}
-//------------------------------------------------------------------------------
-void StreamBaseClass::write(char c) {
-  StreamBaseFile::write(&c, 1);
-}