Reduce need for UNUSED

Marlin/src/HAL/HAL_AVR/HAL.h

 #define DISABLE_TEMPERATURE_INTERRUPT()    CBI(TIMSK0, OCIE0B)
 #define TEMPERATURE_ISR_ENABLED()         TEST(TIMSK0, OCIE0B)
 
-FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
-  UNUSED(frequency);
+FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
   switch (timer_num) {
     case STEP_TIMER_NUM:
       // waveform generation = 0100 = CTC

Marlin/src/HAL/HAL_AVR/HAL_SPI.cpp

   // nop to tune soft SPI timing
   #define nop asm volatile ("\tnop\n")
 
-  // Set SPI rate
-  void spiInit(uint8_t spiRate) {
-    UNUSED(spiRate);  // nothing to do
-  }
+  void spiInit(uint8_t) { /* do nothing */ }
 
   // Begin SPI transaction, set clock, bit order, data mode
-  void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) {
-    UNUSED(spiBeginTransaction);  // nothing to do
-  }
+  void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) { /* do nothing */ }
 
   // Soft SPI receive byte
   uint8_t spiRec() {

Marlin/src/HAL/HAL_DUE/HAL_SPI.cpp

     (((uint32_t)(addr) & 0xF0000000) + 0x02000000 + ((uint32_t)(addr)&0xFFFFF)*32 + (bit)*4)
 
   // run at ~8 .. ~10Mhz - Rx version (Tx line not altered)
-  static uint8_t spiTransferRx0(uint8_t bout) { // using Mode 0
+  static uint8_t spiTransferRx0(uint8_t) { // using Mode 0
     uint32_t bin = 0;
     uint32_t work = 0;
     uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(MISO_PIN))+0x3C, PIN_SHIFT(MISO_PIN));  /* PDSR of port in bitband area */
     uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
     uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
-    UNUSED(bout);
 
     /* The software SPI routine */
     __asm__ __volatile__(

Marlin/src/HAL/HAL_DUE/MarlinSerialUSB.cpp

 #endif
 
 // Public Methods
-void MarlinSerialUSB::begin(const long baud_setting) {
-  UNUSED(baud_setting);
-}
+void MarlinSerialUSB::begin(const long) {}
 
-void MarlinSerialUSB::end() {
-}
+void MarlinSerialUSB::end() {}
 
 int MarlinSerialUSB::peek() {
   if (pending_char >= 0)

Marlin/src/HAL/HAL_DUE/usb/sd_mmc_spi_mem.cpp

   return CTRL_GOOD;
 }
 
-bool sd_mmc_spi_unload(bool unload) {
-  UNUSED(unload);
-  return true;
-}
+bool sd_mmc_spi_unload(bool) { return true; }
 
-bool sd_mmc_spi_wr_protect() {
-  return false;
-}
+bool sd_mmc_spi_wr_protect() { return false; }
 
 bool sd_mmc_spi_removal() {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return true;
-  return false;
+  return (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted());
 }
 
 #if ACCESS_USB == true

Marlin/src/HAL/HAL_ESP32/watchdog.h

 void watchdog_init();
 
 // Reset watchdog.
-inline void HAL_watchdog_refresh() { }
+inline void HAL_watchdog_refresh() {}

Marlin/src/HAL/HAL_LINUX/HAL.h

 #define ENABLE_ISRS()
 #define DISABLE_ISRS()
 
-inline void HAL_init() { }
+inline void HAL_init() {}
 
 // Utility functions
 #pragma GCC diagnostic push

Marlin/src/HAL/HAL_LINUX/include/serial.h

 
   HalSerial() { host_connected = true; }
 
-  void begin(int32_t baud) { }
+  void begin(int32_t) {}
 
-  void end() { }
+  void end() {}
 
   int peek() {
     uint8_t value;

Marlin/src/HAL/HAL_LPC1768/MarlinSerial.h

     {
     }
 
-  void end() { }
+  void end() {}
 
   #if ENABLED(EMERGENCY_PARSER)
     bool recv_callback(const char c) override {

Marlin/src/HAL/HAL_STM32/HAL.cpp

 // ADC
 // ------------------------
 
-void HAL_adc_start_conversion(const uint8_t adc_pin) {
-  HAL_adc_result = analogRead(adc_pin);
-}
+// TODO: Make sure this doesn't cause any delay
+void HAL_adc_start_conversion(const uint8_t adc_pin) { HAL_adc_result = analogRead(adc_pin); }
 
-uint16_t HAL_adc_get_result() {
-  return HAL_adc_result;
-}
+uint16_t HAL_adc_get_result() { return HAL_adc_result; }
 
-void flashFirmware(int16_t value) {
-  UNUSED(value);
-  NVIC_SystemReset();
-}
+void flashFirmware(int16_t) { NVIC_SystemReset(); }
 
 #endif // ARDUINO_ARCH_STM32 && !STM32GENERIC

Marlin/src/HAL/HAL_STM32_F4_F7/HAL.h

 // Memory related
 #define __bss_end __bss_end__
 
-inline void HAL_init() { }
+inline void HAL_init() {}
 
 // Clear reset reason
 void HAL_clear_reset_source();

Marlin/src/HAL/HAL_TEENSY31_32/HAL.h

 #undef pgm_read_word
 #define pgm_read_word(addr) (*((uint16_t*)(addr)))
 
-inline void HAL_init() { }
+inline void HAL_init() {}
 
 // Clear the reset reason
 void HAL_clear_reset_source();

Marlin/src/HAL/HAL_TEENSY35_36/HAL.h

 #undef pgm_read_word
 #define pgm_read_word(addr) (*((uint16_t*)(addr)))
 
-inline void HAL_init() { }
+inline void HAL_init() {}
 
 // Clear reset reason
 void HAL_clear_reset_source();

Marlin/src/HAL/shared/Delay.h

 
     FORCE_INLINE static void DELAY_CYCLES(const uint32_t x) {
       const uint32_t endCycles = getCycleCount() + x;
-      while (PENDING(getCycleCount(), endCycles)) { }
+      while (PENDING(getCycleCount(), endCycles)) {}
     }
 
   #else

Marlin/src/feature/Max7219_Debug_LEDs.h

 public:
   static uint8_t led_line[MAX7219_LINES];
 
-  Max7219() { }
+  Max7219() {}
 
   static void init();
   static void register_setup();

Marlin/src/feature/leds/pca9632.cpp

 
 #if ENABLED(PCA9632_BUZZER)
 
-  void pca9632_buzz(const long duration, const uint16_t freq) {
-    UNUSED(duration); UNUSED(freq);
+  void pca9632_buzz(const long, const uint16_t) {
     uint8_t data[] = PCA9632_BUZZER_DATA;
     Wire.beginTransmission(I2C_ADDRESS(PCA9632_ADDRESS));
     Wire.write(data, sizeof(data));

Marlin/src/feature/power_loss_recovery.h

   #if ENABLED(DEBUG_POWER_LOSS_RECOVERY)
     static void debug(PGM_P const prefix);
   #else
-    static inline void debug(PGM_P const prefix) { UNUSED(prefix); }
+    static inline void debug(PGM_P const) {}
   #endif
 
   private:

Marlin/src/feature/runout.h

       }
 
     public:
-      static inline void block_completed(const block_t* const b) { UNUSED(b); }
+      static inline void block_completed(const block_t* const) {}
 
       static inline void run() {
         const bool out = poll_runout_state(active_extruder);
       static inline void reset()                                  { runout_count = runout_threshold; }
       static inline void run()                                    { if (runout_count >= 0) runout_count--; }
       static inline bool has_run_out()                            { return runout_count < 0; }
-      static inline void block_completed(const block_t* const b)  { UNUSED(b); }
-      static inline void filament_present(const uint8_t extruder) { runout_count = runout_threshold; UNUSED(extruder); }
+      static inline void block_completed(const block_t* const)    { }
+      static inline void filament_present(const uint8_t)          { runout_count = runout_threshold; }
   };
 
 #endif // !FILAMENT_RUNOUT_DISTANCE_MM

Marlin/src/feature/spindle_laser.h

   #if ENABLED(SPINDLE_CHANGE_DIR)
     static void set_direction(const bool reverse);
   #else
-    static inline void set_direction(const bool reverse) { UNUSED(reverse); }
+    static inline void set_direction(const bool) {}
   #endif
 
   static inline void disable() { set_enabled(false); }

Marlin/src/gcode/parser.h

     static inline float mm_to_linear_unit(const float mm)     { return mm; }
     static inline float mm_to_volumetric_unit(const float mm) { return mm; }
 
-    static inline float linear_value_to_mm(const float v)                    { return v; }
-    static inline float axis_value_to_mm(const AxisEnum axis, const float v) { UNUSED(axis); return v; }
-    static inline float per_axis_value(const AxisEnum axis, const float v)   { UNUSED(axis); return v; }
+    static inline float linear_value_to_mm(const float v)               { return v; }
+    static inline float axis_value_to_mm(const AxisEnum, const float v) { return v; }
+    static inline float per_axis_value(const AxisEnum, const float v)   { return v; }
 
   #endif
 

Marlin/src/lcd/menu/menu.h

   FORCE_INLINE void draw_menu_item_edit_##NAME (const bool sel, const uint8_t row, PGM_P const pstr, TYPE * const data, ...) { \
     DRAW_MENU_ITEM_SETTING_EDIT_GENERIC(STRFUNC(*(data))); \
   } \
-  FORCE_INLINE void draw_menu_item_edit_accessor_##NAME (const bool sel, const uint8_t row, PGM_P const pstr, PGM_P const pstr2, TYPE (*pget)(), void (*pset)(TYPE), ...) { \
-    UNUSED(pstr2); UNUSED(pset); \
+  FORCE_INLINE void draw_menu_item_edit_accessor_##NAME (const bool sel, const uint8_t row, PGM_P const pstr, PGM_P const, TYPE (*pget)(), void (*)(TYPE), ...) { \
     DRAW_MENU_ITEM_SETTING_EDIT_GENERIC(STRFUNC(pget())); \
   } \
   typedef void NAME##_void
 
 class MenuItem_back {
   public:
-    static inline void action(PGM_P const dummy=nullptr) {
+    static inline void action(PGM_P const=nullptr) {
       ui.goto_previous_screen(
         #if ENABLED(TURBO_BACK_MENU_ITEM)
           true
         #endif
       );
-      UNUSED(dummy);
     }
 };
 

Marlin/src/lcd/menu/menu_media.cpp

         MenuItem_submenu::action(pstr, menu_sd_confirm);
       #else
         sdcard_start_selected_file();
+        UNUSED(pstr);
       #endif
     }
 };

Marlin/src/lcd/ultralcd.h

 
     static void init();
     static void update();
-    static void set_alert_status_P(PGM_P message);
+    static void set_alert_status_P(PGM_P const message);
 
     static char status_message[];
     static bool has_status();
     static inline void update() {}
     static inline void refresh() {}
     static inline void return_to_status() {}
-    static inline void set_alert_status_P(PGM_P message) { UNUSED(message); }
-    static inline void set_status(const char* const message, const bool persist=false) { UNUSED(message); UNUSED(persist); }
-    static inline void set_status_P(PGM_P const message, const int8_t level=0) { UNUSED(message); UNUSED(level); }
-    static inline void status_printf_P(const uint8_t level, PGM_P const fmt, ...) { UNUSED(level); UNUSED(fmt); }
+    static inline void set_alert_status_P(PGM_P const) {}
+    static inline void set_status(const char* const, const bool=false) {}
+    static inline void set_status_P(PGM_P const, const int8_t=0) {}
+    static inline void status_printf_P(const uint8_t, PGM_P const, ...) {}
     static inline void reset_status() {}
     static inline void reset_alert_level() {}
     static constexpr bool has_status() { return false; }

Marlin/src/module/configuration_store.h

       static void report(const bool forReplay=false);
     #else
       FORCE_INLINE
-      static void report(const bool forReplay=false) { UNUSED(forReplay); }
+      static void report(const bool=false) {}
     #endif
 
   private:

Marlin/src/module/motion.h

 #else
   #define NATIVE_TO_LOGICAL(POS, AXIS) (POS)
   #define LOGICAL_TO_NATIVE(POS, AXIS) (POS)
-  FORCE_INLINE void toLogical(xy_pos_t &raw)   { UNUSED(raw); }
-  FORCE_INLINE void toLogical(xyz_pos_t &raw)  { UNUSED(raw); }
-  FORCE_INLINE void toLogical(xyze_pos_t &raw) { UNUSED(raw); }
-  FORCE_INLINE void toNative(xy_pos_t &raw)    { UNUSED(raw); }
-  FORCE_INLINE void toNative(xyz_pos_t &raw)   { UNUSED(raw); }
-  FORCE_INLINE void toNative(xyze_pos_t &raw)  { UNUSED(raw); }
+  FORCE_INLINE void toLogical(xy_pos_t&)   {}
+  FORCE_INLINE void toLogical(xyz_pos_t&)  {}
+  FORCE_INLINE void toLogical(xyze_pos_t&) {}
+  FORCE_INLINE void toNative(xy_pos_t&)    {}
+  FORCE_INLINE void toNative(xyz_pos_t&)   {}
+  FORCE_INLINE void toNative(xyze_pos_t&)  {}
 #endif
 #define LOGICAL_X_POSITION(POS) NATIVE_TO_LOGICAL(POS, X_AXIS)
 #define LOGICAL_Y_POSITION(POS) NATIVE_TO_LOGICAL(POS, Y_AXIS)

Marlin/src/module/planner.h

 
     #else
 
-      FORCE_INLINE static float fade_scaling_factor_for_z(const float &rz) {
-        UNUSED(rz);
-        return 1;
-      }
+      FORCE_INLINE static float fade_scaling_factor_for_z(const float&) { return 1; }
 
-      FORCE_INLINE static bool leveling_active_at_z(const float &rz) { UNUSED(rz); return true; }
+      FORCE_INLINE static bool leveling_active_at_z(const float&) { return true; }
 
     #endif
 

Marlin/src/module/stepper.h

     //
     // Constructor / initializer
     //
-    Stepper() { };
+    Stepper() {};
 
     // Initialize stepper hardware
     static void init();

Marlin/src/module/temperature.cpp

 
 #if HOTENDS
 
-  float Temperature::get_pid_output_hotend(const uint8_t e) {
-    #if HOTENDS == 1
-      #define _HOTEND_TEST true
-    #else
-      #define _HOTEND_TEST (e == active_extruder)
-    #endif
-    E_UNUSED();
+  float Temperature::get_pid_output_hotend(const uint8_t E_NAME) {
     const uint8_t ee = HOTEND_INDEX;
     #if ENABLED(PIDTEMP)
       #if DISABLED(PID_OPENLOOP)
           pid_output = work_pid[ee].Kp + work_pid[ee].Ki + work_pid[ee].Kd + float(MIN_POWER);
 
           #if ENABLED(PID_EXTRUSION_SCALING)
+            #if HOTENDS == 1
+              constexpr bool this_hotend = true;
+            #else
+              const bool this_hotend = (e == active_extruder);
+            #endif
             work_pid[ee].Kc = 0;
-            if (_HOTEND_TEST) {
+            if (this_hotend) {
               const long e_position = stepper.position(E_AXIS);
               if (e_position > last_e_position) {
                 lpq[lpq_ptr] = e_position - last_e_position;
             MSG_PID_DEBUG_OUTPUT, pid_output
           );
           #if DISABLED(PID_OPENLOOP)
+          {
             SERIAL_ECHOPAIR(
               MSG_PID_DEBUG_PTERM, work_pid[ee].Kp,
               MSG_PID_DEBUG_ITERM, work_pid[ee].Ki,
                 , MSG_PID_DEBUG_CTERM, work_pid[ee].Kc
               #endif
             );
+          }
           #endif
           SERIAL_EOL();
         }
     #else // No PID enabled
 
       #if HEATER_IDLE_HANDLER
-        #define _TIMED_OUT_TEST hotend_idle[ee].timed_out
+        const bool is_idling = hotend_idle[ee].timed_out;
       #else
-        #define _TIMED_OUT_TEST false
+        constexpr bool is_idling = false;
       #endif
-      const float pid_output = (!_TIMED_OUT_TEST && temp_hotend[ee].celsius < temp_hotend[ee].target) ? BANG_MAX : 0;
-      #undef _TIMED_OUT_TEST
+      const float pid_output = (!is_idling && temp_hotend[ee].celsius < temp_hotend[ee].target) ? BANG_MAX : 0;
 
     #endif
 
     #endif // PID_OPENLOOP
 
     #if ENABLED(PID_BED_DEBUG)
+    {
       SERIAL_ECHO_START();
       SERIAL_ECHOLNPAIR(
         " PID_BED_DEBUG : Input ", temp_bed.celsius, " Output ", pid_output,
           MSG_PID_DEBUG_DTERM, work_pid.Kd,
         #endif
       );
+    }
     #endif
 
     return pid_output;
    * their target temperature by a configurable margin.
    * This is called when the temperature is set. (M104, M109)
    */
-  void Temperature::start_watching_hotend(const uint8_t e) {
-    E_UNUSED();
+  void Temperature::start_watching_hotend(const uint8_t E_NAME) {
     const uint8_t ee = HOTEND_INDEX;
     if (degTargetHotend(ee) && degHotend(ee) < degTargetHotend(ee) - (WATCH_TEMP_INCREASE + TEMP_HYSTERESIS + 1)) {
       watch_hotend[ee].target = degHotend(ee) + WATCH_TEMP_INCREASE;

Marlin/src/module/temperature.h

 
 #if HOTENDS <= 1
   #define HOTEND_INDEX  0
-  #define E_UNUSED() UNUSED(e)
+  #define E_NAME
 #else
   #define HOTEND_INDEX  e
-  #define E_UNUSED()
+  #define E_NAME e
 #endif
 
 // Identifiers for other heaters
       static bool allow_cold_extrude;
       static int16_t extrude_min_temp;
       FORCE_INLINE static bool tooCold(const int16_t temp) { return allow_cold_extrude ? false : temp < extrude_min_temp; }
-      FORCE_INLINE static bool tooColdToExtrude(const uint8_t e) {
-        E_UNUSED();
+      FORCE_INLINE static bool tooColdToExtrude(const uint8_t E_NAME) {
         return tooCold(degHotend(HOTEND_INDEX));
       }
-      FORCE_INLINE static bool targetTooColdToExtrude(const uint8_t e) {
-        E_UNUSED();
+      FORCE_INLINE static bool targetTooColdToExtrude(const uint8_t E_NAME) {
         return tooCold(degTargetHotend(HOTEND_INDEX));
       }
     #else
-      FORCE_INLINE static bool tooColdToExtrude(const uint8_t e) { UNUSED(e); return false; }
-      FORCE_INLINE static bool targetTooColdToExtrude(const uint8_t e) { UNUSED(e); return false; }
+      FORCE_INLINE static bool tooColdToExtrude(const uint8_t) { return false; }
+      FORCE_INLINE static bool targetTooColdToExtrude(const uint8_t) { return false; }
     #endif
 
     FORCE_INLINE static bool hotEnoughToExtrude(const uint8_t e) { return !tooColdToExtrude(e); }
      * Preheating hotends
      */
     #ifdef MILLISECONDS_PREHEAT_TIME
-      static bool is_preheating(const uint8_t e) {
-        E_UNUSED();
+      static bool is_preheating(const uint8_t E_NAME) {
         return preheat_end_time[HOTEND_INDEX] && PENDING(millis(), preheat_end_time[HOTEND_INDEX]);
       }
-      static void start_preheat_time(const uint8_t e) {
-        E_UNUSED();
+      static void start_preheat_time(const uint8_t E_NAME) {
         preheat_end_time[HOTEND_INDEX] = millis() + MILLISECONDS_PREHEAT_TIME;
       }
-      static void reset_preheat_time(const uint8_t e) {
-        E_UNUSED();
+      static void reset_preheat_time(const uint8_t E_NAME) {
         preheat_end_time[HOTEND_INDEX] = 0;
       }
     #else
     //inline so that there is no performance decrease.
     //deg=degreeCelsius
 
-    FORCE_INLINE static float degHotend(const uint8_t e) {
-      E_UNUSED();
-      #if HOTENDS
-        return temp_hotend[HOTEND_INDEX].celsius;
-      #else
-        return 0;
-      #endif
+    FORCE_INLINE static float degHotend(const uint8_t E_NAME) {
+      return (0
+        #if HOTENDS
+          + temp_hotend[HOTEND_INDEX].celsius
+        #endif
+      );
     }
 
     #if ENABLED(SHOW_TEMP_ADC_VALUES)
-      FORCE_INLINE static int16_t rawHotendTemp(const uint8_t e) {
-        E_UNUSED();
-        #if HOTENDS
-          return temp_hotend[HOTEND_INDEX].raw;
-        #else
-          return 0;
-        #endif
+      FORCE_INLINE static int16_t rawHotendTemp(const uint8_t E_NAME) {
+        return (0
+          #if HOTENDS
+            + temp_hotend[HOTEND_INDEX].raw
+          #endif
+        );
       }
     #endif
 
-    FORCE_INLINE static int16_t degTargetHotend(const uint8_t e) {
-      E_UNUSED();
-      #if HOTENDS
-        return temp_hotend[HOTEND_INDEX].target;
-      #else
-        return 0;
-      #endif
+    FORCE_INLINE static int16_t degTargetHotend(const uint8_t E_NAME) {
+      return (0
+        #if HOTENDS
+          + temp_hotend[HOTEND_INDEX].target
+        #endif
+      );
     }
 
     #if WATCH_HOTENDS
       static void start_watching_hotend(const uint8_t e=0);
     #else
-      static inline void start_watching_hotend(const uint8_t e=0) { UNUSED(e); }
+      static inline void start_watching_hotend(const uint8_t=0) {}
     #endif
 
     #if HOTENDS
         static inline void start_watching_E5() { start_watching_hotend(5); }
       #endif
 
-      static void setTargetHotend(const int16_t celsius, const uint8_t e) {
-        E_UNUSED();
+      static void setTargetHotend(const int16_t celsius, const uint8_t E_NAME) {
         const uint8_t ee = HOTEND_INDEX;
         #ifdef MILLISECONDS_PREHEAT_TIME
           if (celsius == 0)
         start_watching_hotend(ee);
       }
 
-      FORCE_INLINE static bool isHeatingHotend(const uint8_t e) {
-        E_UNUSED();
+      FORCE_INLINE static bool isHeatingHotend(const uint8_t E_NAME) {
         return temp_hotend[HOTEND_INDEX].target > temp_hotend[HOTEND_INDEX].celsius;
       }
 
-      FORCE_INLINE static bool isCoolingHotend(const uint8_t e) {
-        E_UNUSED();
+      FORCE_INLINE static bool isCoolingHotend(const uint8_t E_NAME) {
         return temp_hotend[HOTEND_INDEX].target < temp_hotend[HOTEND_INDEX].celsius;
       }
 
 
     #if HEATER_IDLE_HANDLER
 
-      static void reset_heater_idle_timer(const uint8_t e) {
-        E_UNUSED();
+      static void reset_heater_idle_timer(const uint8_t E_NAME) {
         hotend_idle[HOTEND_INDEX].reset();
         start_watching_hotend(HOTEND_INDEX);
       }

Marlin/src/sd/usb_flashdrive/Sd2Card_FlashDrive.h

 
     static void idle();
 
-    inline bool readStart(const uint32_t block)                             { pos = block; return ready(); }
-    inline bool readData(uint8_t* dst)                                      { return readBlock(pos++, dst); }
-    inline bool readStop() const                                            { return true; }
+    inline bool readStart(const uint32_t block)                  { pos = block; return ready(); }
+    inline bool readData(uint8_t* dst)                           { return readBlock(pos++, dst); }
+    inline bool readStop() const                                 { return true; }
 
-    inline bool writeStart(const uint32_t block, const uint32_t eraseCount) { UNUSED(eraseCount); pos = block; return ready(); }
-    inline bool writeData(uint8_t* src)                                     { return writeBlock(pos++, src); }
-    inline bool writeStop() const                                           { return true; }
+    inline bool writeStart(const uint32_t block, const uint32_t) { pos = block; return ready(); }
+    inline bool writeData(uint8_t* src)                          { return writeBlock(pos++, src); }
+    inline bool writeStop() const                                { return true; }
 
     bool readBlock(uint32_t block, uint8_t* dst);
     bool writeBlock(uint32_t blockNumber, const uint8_t* src);

Marlin/src/sd/usb_flashdrive/lib-uhs2/parsetools.h

     lenSize(0),
     valSize(0),
     pBuf(nullptr),
-    prsMode(modeArray) { }
+    prsMode(modeArray) {}
   ;
 
   void Initialize(const uint8_t len_size, const uint8_t val_size, MultiValueBuffer * const p, const uint8_t mode = modeArray) {