Coolstep for TMC2130, 2209, 5130, 5160 (#16790)

Marlin/Configuration.h

 //#define X_DRIVER_TYPE  A4988
 //#define Y_DRIVER_TYPE  A4988
 //#define Z_DRIVER_TYPE  A4988
-//#define X2_DRIVER_TYPE A4988
-//#define Y2_DRIVER_TYPE A4988
-//#define Z2_DRIVER_TYPE A4988
-//#define Z3_DRIVER_TYPE A4988
-//#define Z4_DRIVER_TYPE A4988
 //#define E0_DRIVER_TYPE A4988
 //#define E1_DRIVER_TYPE A4988
 //#define E2_DRIVER_TYPE A4988

Marlin/Configuration_adv.h

   #define E7_HYBRID_THRESHOLD     30
 
   /**
+   * CoolStep. Currently supported for TMC2130, TMC2209, TMC5130 and TMC5160 only.
+   * This mode allows for cooler steppers and energy savings.
+   * The driver will switch to coolStep when stepper speed is over COOLSTEP_THRESHOLD mm/s.
+   *
+   * If SG_RESULT goes below COOLSTEP_LOWER_LOAD_THRESHOLD * 32 stepper current will be increased.
+   * Set to 0 to disable CoolStep.
+   *
+   * If SG_RESULT goes above (COOLSTEP_LOWER_LOAD_THRESHOLD + COOLSTEP_UPPER_LOAD_THRESHOLD + 1) * 32
+   * stepper current will be decreased.
+   *
+   * SEUP sets the increase step width. Value range is 0..3 and computed as 2^SEUP.
+   * SEDN sets the decrease delay. Value range is 0..3, 0 being the slowest.
+   * SEIMIN sets the lower current limit. 0: 1/2 of IRUN, 1:1/4 of IRUN
+   */
+
+  #if AXIS_HAS_COOLSTEP(X)
+    #define X_COOLSTEP_SPEED_THRESHOLD        5
+    #define X_COOLSTEP_LOWER_LOAD_THRESHOLD   7
+    #define X_COOLSTEP_UPPER_LOAD_THRESHOLD   0
+    #define X_COOLSTEP_SEUP                   2
+    #define X_COOLSTEP_SEDN                   0
+    #define X_COOLSTEP_SEIMIN                 1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(X2)
+    #define X2_COOLSTEP_SPEED_THRESHOLD       5
+    #define X2_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define X2_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define X2_COOLSTEP_SEUP                  2
+    #define X2_COOLSTEP_SEDN                  0
+    #define X2_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(Y)
+    #define Y_COOLSTEP_SPEED_THRESHOLD        5
+    #define Y_COOLSTEP_LOWER_LOAD_THRESHOLD   7
+    #define Y_COOLSTEP_UPPER_LOAD_THRESHOLD   0
+    #define Y_COOLSTEP_SEUP                   2
+    #define Y_COOLSTEP_SEDN                   0
+    #define Y_COOLSTEP_SEIMIN                 1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(Y2)
+    #define Y2_COOLSTEP_SPEED_THRESHOLD       5
+    #define Y2_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define Y2_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define Y2_COOLSTEP_SEUP                  2
+    #define Y2_COOLSTEP_SEDN                  0
+    #define Y2_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(Z)
+    #define Z_COOLSTEP_SPEED_THRESHOLD        5
+    #define Z_COOLSTEP_LOWER_LOAD_THRESHOLD   7
+    #define Z_COOLSTEP_UPPER_LOAD_THRESHOLD   0
+    #define Z_COOLSTEP_SEUP                   2
+    #define Z_COOLSTEP_SEDN                   0
+    #define Z_COOLSTEP_SEIMIN                 1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(Z2)
+    #define Z2_COOLSTEP_SPEED_THRESHOLD       5
+    #define Z2_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define Z2_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define Z2_COOLSTEP_SEUP                  2
+    #define Z2_COOLSTEP_SEDN                  0
+    #define Z2_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(Z3)
+    #define Z3_COOLSTEP_SPEED_THRESHOLD       5
+    #define Z3_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define Z3_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define Z3_COOLSTEP_SEUP                  2
+    #define Z3_COOLSTEP_SEDN                  0
+    #define Z3_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(Z4)
+    #define Z4_COOLSTEP_SPEED_THRESHOLD       5
+    #define Z4_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define Z4_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define Z4_COOLSTEP_SEUP                  2
+    #define Z4_COOLSTEP_SEDN                  0
+    #define Z4_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(E0)
+    #define E0_COOLSTEP_SPEED_THRESHOLD       5
+    #define E0_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define E0_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define E0_COOLSTEP_SEUP                  2
+    #define E0_COOLSTEP_SEDN                  0
+    #define E0_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(E1)
+    #define E1_COOLSTEP_SPEED_THRESHOLD       5
+    #define E1_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define E1_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define E1_COOLSTEP_SEUP                  2
+    #define E1_COOLSTEP_SEDN                  0
+    #define E1_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(E2)
+    #define E2_COOLSTEP_SPEED_THRESHOLD       5
+    #define E2_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define E2_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define E2_COOLSTEP_SEUP                  2
+    #define E2_COOLSTEP_SEDN                  0
+    #define E2_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(E3)
+    #define E3_COOLSTEP_SPEED_THRESHOLD       5
+    #define E3_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define E3_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define E3_COOLSTEP_SEUP                  2
+    #define E3_COOLSTEP_SEDN                  0
+    #define E3_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(E4)
+    #define E4_COOLSTEP_SPEED_THRESHOLD       5
+    #define E4_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define E4_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define E4_COOLSTEP_SEUP                  2
+    #define E4_COOLSTEP_SEDN                  0
+    #define E4_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(E5)
+    #define E5_COOLSTEP_SPEED_THRESHOLD       5
+    #define E5_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define E5_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define E5_COOLSTEP_SEUP                  2
+    #define E5_COOLSTEP_SEDN                  0
+    #define E5_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(E6)
+    #define E6_COOLSTEP_SPEED_THRESHOLD       5
+    #define E6_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define E6_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define E6_COOLSTEP_SEUP                  2
+    #define E6_COOLSTEP_SEDN                  0
+    #define E6_COOLSTEP_SEIMIN                1
+  #endif
+
+  #if AXIS_HAS_COOLSTEP(E7)
+    #define E7_COOLSTEP_SPEED_THRESHOLD       5
+    #define E7_COOLSTEP_LOWER_LOAD_THRESHOLD  7
+    #define E7_COOLSTEP_UPPER_LOAD_THRESHOLD  0
+    #define E7_COOLSTEP_SEUP                  2
+    #define E7_COOLSTEP_SEDN                  0
+    #define E7_COOLSTEP_SEIMIN                1
+  #endif
+
+  /**
    * Use StallGuard2 to home / probe X, Y, Z.
    *
    * TMC2130, TMC2160, TMC2209, TMC2660, TMC5130, and TMC5160 only

Marlin/src/HAL/HAL_AVR/inc/SanityCheck.h

   #error "TMCStepper includes SoftwareSerial.h which is incompatible with ENDSTOP_INTERRUPTS_FEATURE. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
 #endif
 
-#if TMC_HAS_SW_SERIAL && ENABLED(MONITOR_DRIVER_STATUS)
+#if HAS_TMC_SW_SERIAL && ENABLED(MONITOR_DRIVER_STATUS)
   #error "MONITOR_DRIVER_STATUS causes performance issues when used with SoftwareSerial-connected drivers. Disable MONITOR_DRIVER_STATUS or use hardware serial to continue."
 #endif

Marlin/src/HAL/HAL_DUE/inc/SanityCheck.h

   #error "FAST_PWM_FAN is not yet implemented for this platform."
 #endif
 
-#if TMC_HAS_SW_SERIAL
+#if HAS_TMC_SW_SERIAL
   #error "TMC220x Software Serial is not supported on this platform."
 #endif

Marlin/src/HAL/HAL_ESP32/inc/SanityCheck.h

   #error "FAST_PWM_FAN is not yet implemented for this platform."
 #endif
 
-#if TMC_HAS_SW_SERIAL
+#if HAS_TMC_SW_SERIAL
   #error "TMC220x Software Serial is not supported on this platform."
 #endif
 

Marlin/src/HAL/HAL_LINUX/inc/SanityCheck.h

   #error "FAST_PWM_FAN is not yet implemented for this platform."
 #endif
 
-#if TMC_HAS_SW_SERIAL
+#if HAS_TMC_SW_SERIAL
   #error "TMC220x Software Serial is not supported on this platform."
 #endif

Marlin/src/HAL/HAL_SAMD51/inc/SanityCheck.h

   #warning "Did you activate the SmartEEPROM? See https://github.com/GMagician/SAMD51-SmartEEprom-Activator"
 #endif
 
-#if TMC_HAS_SW_SERIAL
+#if HAS_TMC_SW_SERIAL
   #error "TMC220x Software Serial is not supported on this platform."
 #endif

Marlin/src/HAL/HAL_STM32/HAL.cpp

 #include "../../inc/MarlinConfig.h"
 #include "../shared/Delay.h"
 
-#if TMC_HAS_SW_SERIAL
+#if HAS_TMC_SW_SERIAL
   #include "SoftwareSerial.h"
 #endif
 
   while (!LL_PWR_IsActiveFlag_BRR());
   #endif // EEPROM_EMULATED_SRAM
 
-  #if TMC_HAS_SW_SERIAL
+  #if HAS_TMC_SW_SERIAL
     SoftwareSerial::setInterruptPriority(SWSERIAL_TIMER_IRQ_PRIO, 0);
   #endif
 }

Marlin/src/HAL/HAL_STM32F1/inc/SanityCheck.h

   #error "FAST_PWM_FAN is not yet implemented for this platform."
 #endif
 
-#if !defined(HAVE_SW_SERIAL) && TMC_HAS_SW_SERIAL
+#if !defined(HAVE_SW_SERIAL) && HAS_TMC_SW_SERIAL
   #warning "With TMC2208/9 consider using SoftwareSerialM with HAVE_SW_SERIAL and appropriate SS_TIMER."
   #error "Missing SoftwareSerial implementation."
 #endif

Marlin/src/HAL/HAL_STM32_F4_F7/inc/SanityCheck.h

   #error "FAST_PWM_FAN is not yet implemented for this platform."
 #endif
 
-#if TMC_HAS_SW_SERIAL
+#if HAS_TMC_SW_SERIAL
   #error "TMC220x Software Serial is not supported on this platform."
 #endif

Marlin/src/HAL/HAL_TEENSY31_32/inc/SanityCheck.h

   #error "FAST_PWM_FAN is not yet implemented for this platform."
 #endif
 
-#if TMC_HAS_SW_SERIAL
+#if HAS_TMC_SW_SERIAL
   #error "TMC220x Software Serial is not supported on this platform."
 #endif

Marlin/src/HAL/HAL_TEENSY35_36/inc/SanityCheck.h

   #error "FAST_PWM_FAN is not yet implemented for this platform."
 #endif
 
-#if TMC_HAS_SW_SERIAL
+#if HAS_TMC_SW_SERIAL
   #error "TMC220x Software Serial is not supported on this platform."
 #endif

Marlin/src/MarlinCore.cpp

   SERIAL_ECHOLNPGM("start");
   SERIAL_ECHO_START();
 
-  #if TMC_HAS_SPI
+  #if HAS_TMC_SPI
     #if DISABLED(TMC_USE_SW_SPI)
       SPI.begin();
     #endif

Marlin/src/core/drivers.h

 #define _TMC5160_STANDALONE 0x5160B
 
 #define _DRIVER_ID(V) _CAT(_, V)
-#define _AXIS_DRIVER_TYPE(A,T) (_DRIVER_ID(A##_DRIVER_TYPE) == _CAT(_, T))
+#define _AXIS_DRIVER_TYPE(A,T) (_DRIVER_ID(A##_DRIVER_TYPE) == _DRIVER_ID(T))
 
 #define AXIS_DRIVER_TYPE_X(T) _AXIS_DRIVER_TYPE(X,T)
 #define AXIS_DRIVER_TYPE_Y(T) _AXIS_DRIVER_TYPE(Y,T)
                                    || AXIS_DRIVER_TYPE(A,TMC5130) \
                                    || AXIS_DRIVER_TYPE(A,TMC5160) )
 
+#define AXIS_HAS_SG_RESULT(A)    (    AXIS_DRIVER_TYPE(A,TMC2130) \
+                                   || AXIS_DRIVER_TYPE(A,TMC2160) \
+                                   || AXIS_DRIVER_TYPE(A,TMC2208) \
+                                   || AXIS_DRIVER_TYPE(A,TMC2209) )
+
+#define AXIS_HAS_COOLSTEP(A)     (    AXIS_DRIVER_TYPE(A,TMC2130) \
+                                   || AXIS_DRIVER_TYPE(A,TMC2209) \
+                                   || AXIS_DRIVER_TYPE(A,TMC5130) \
+                                   || AXIS_DRIVER_TYPE(A,TMC5160) )
+
+#define _OR_EAH(N,T)    || AXIS_HAS_##T(E##N)
+#define E_AXIS_HAS(T)   (0 RREPEAT2(E_STEPPERS, _OR_EAH, T))
+
 #define ANY_AXIS_HAS(T) (    AXIS_HAS_##T(X)  || AXIS_HAS_##T(X2) \
                           || AXIS_HAS_##T(Y)  || AXIS_HAS_##T(Y2) \
                           || AXIS_HAS_##T(Z)  || AXIS_HAS_##T(Z2) \
-                          || AXIS_HAS_##T(Z3) \
-                          || AXIS_HAS_##T(E0) || AXIS_HAS_##T(E1) \
-                          || AXIS_HAS_##T(E2) || AXIS_HAS_##T(E3) \
-                          || AXIS_HAS_##T(E4) || AXIS_HAS_##T(E5) \
-                          || AXIS_HAS_##T(E6) || AXIS_HAS_##T(E7) )
+                          || AXIS_HAS_##T(Z3) || AXIS_HAS_##T(Z4) \
+                          || E_AXIS_HAS(T) )
 
 #define HAS_STEALTHCHOP    ANY_AXIS_HAS(STEALTHCHOP)
 #define HAS_STALLGUARD     ANY_AXIS_HAS(STALLGUARD)
-#define TMC_HAS_SPI        ANY_AXIS_HAS(SPI)
-#define TMC_HAS_SW_SERIAL  ANY_AXIS_HAS(SW_SERIAL)
+#define HAS_SG_RESULT      ANY_AXIS_HAS(SG_RESULT)
+#define HAS_COOLSTEP       ANY_AXIS_HAS(COOLSTEP)
+#define HAS_TMC_UART       ANY_AXIS_HAS(UART)
+#define HAS_TMC_SPI        ANY_AXIS_HAS(SPI)
+#define HAS_TMC_SW_SERIAL  ANY_AXIS_HAS(SW_SERIAL)
 
 //
 // Stretching 'drivers.h' to include LPC/SAMD51 SD options

Marlin/src/feature/tmc_util.cpp

         default: break;
       }
     }
+
+    #if HAS_DRIVER(TMC2209)
+      static void _tmc_parse_drv_status(TMC2209Stepper &st, const TMC_drv_status_enum i) {
+        switch (i) {
+          case TMC_SG_RESULT: SERIAL_PRINT(st.SG_RESULT(), DEC); break;
+          default:            _tmc_parse_drv_status(static_cast<TMC2208Stepper &>(st), i); break;
+        }
+      }
+    #endif
   #endif
 
   #if HAS_DRIVER(TMC2660)
     TMC_REPORT("stealthChop",        TMC_STEALTHCHOP);
     TMC_REPORT("msteps\t",           TMC_MICROSTEPS);
     TMC_REPORT("tstep\t",            TMC_TSTEP);
-    TMC_REPORT("pwm\nthreshold",     TMC_TPWMTHRS);
+    TMC_REPORT("PWM thresh.",        TMC_TPWMTHRS);
     TMC_REPORT("[mm/s]\t",           TMC_TPWMTHRS_MMS);
     TMC_REPORT("OT prewarn",         TMC_OTPW);
     #if ENABLED(MONITOR_DRIVER_STATUS)
-      TMC_REPORT("OT prewarn has\n"
-                 "been triggered",   TMC_OTPW_TRIGGERED);
+      TMC_REPORT("triggered\n OTP\t", TMC_OTPW_TRIGGERED);
     #endif
     TMC_REPORT("off time",           TMC_TOFF);
     TMC_REPORT("blank time",         TMC_TBL);
-    TMC_REPORT("hysteresis\n-end\t", TMC_HEND);
-    TMC_REPORT("-start\t",           TMC_HSTRT);
+    TMC_REPORT("hysteresis\n -end\t", TMC_HEND);
+    TMC_REPORT(" -start\t",          TMC_HSTRT);
     TMC_REPORT("Stallguard thrs",    TMC_SGT);
-
     DRV_REPORT("DRVSTATUS",          TMC_DRV_CODES);
-    #if HAS_TMCX1X0
-      DRV_REPORT("stallguard\t",     TMC_STALLGUARD);
+    #if HAS_TMCX1X0 || HAS_TMC220x
       DRV_REPORT("sg_result",        TMC_SG_RESULT);
-      DRV_REPORT("fsactive\t",       TMC_FSACTIVE);
+    #endif
+    #if HAS_TMCX1X0
+      DRV_REPORT("stallguard",       TMC_STALLGUARD);
+      DRV_REPORT("fsactive",         TMC_FSACTIVE);
     #endif
     DRV_REPORT("stst\t",             TMC_STST);
     DRV_REPORT("olb\t",              TMC_OLB);
 
 #endif // USE_SENSORLESS
 
-#if TMC_HAS_SPI
+#if HAS_TMC_SPI
   #define SET_CS_PIN(st) OUT_WRITE(st##_CS_PIN, HIGH)
   void tmc_init_cs_pins() {
     #if AXIS_HAS_SPI(X)
       SET_CS_PIN(E7);
     #endif
   }
-#endif // TMC_HAS_SPI
+#endif // HAS_TMC_SPI
 
 template<typename TMC>
 static bool test_connection(TMC &st) {

Marlin/src/feature/tmc_util.h

       inline void refresh_stepping_mode() { this->en_pwm_mode(this->stored.stealthChop_enabled); }
       inline bool get_stealthChop_status() { return this->en_pwm_mode(); }
     #endif
+
     #if ENABLED(HYBRID_THRESHOLD)
       uint32_t get_pwm_thrs() {
         return _tmc_thrs(this->microsteps(), this->TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
         #endif
       }
     #endif
+
     #if USE_SENSORLESS
       inline int16_t homing_threshold() { return TMC::sgt(); }
       void homing_threshold(int16_t sgt_val) {
       #endif
     #endif
 
+    uint32_t get_cool_thrs() {
+      return _tmc_thrs(this->microsteps(), this->TCOOLTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
+    }
+    void set_cool_thrs(const uint32_t thrs) {
+      TMC::TCOOLTHRS(_tmc_thrs(this->microsteps(), thrs, planner.settings.axis_steps_per_mm[AXIS_ID]));
+    }
+
     #if HAS_LCD_MENU
       inline void refresh_stepper_current() { rms_current(this->val_mA); }
 
     static constexpr int8_t sgt_min = -64,
                             sgt_max =  63;
 };
+
 template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
 class TMCMarlin<TMC2208Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC2208Stepper, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
   public:
       inline void refresh_stepping_mode() { en_spreadCycle(!this->stored.stealthChop_enabled); }
       inline bool get_stealthChop_status() { return !this->en_spreadCycle(); }
     #endif
+
     #if ENABLED(HYBRID_THRESHOLD)
       uint32_t get_pwm_thrs() {
         return _tmc_thrs(this->microsteps(), this->TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
       inline void refresh_stepping_mode() { en_spreadCycle(!this->stored.stealthChop_enabled); }
       inline bool get_stealthChop_status() { return !this->en_spreadCycle(); }
     #endif
+
     #if ENABLED(HYBRID_THRESHOLD)
       uint32_t get_pwm_thrs() {
         return _tmc_thrs(this->microsteps(), this->TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
         #endif
       }
     #endif
+
+    uint32_t get_cool_thrs() {
+      return _tmc_thrs(this->microsteps(), this->TCOOLTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
+    }
+    void set_cool_thrs(const uint32_t thrs) {
+      TMC2209Stepper::TCOOLTHRS(_tmc_thrs(this->microsteps(), thrs, planner.settings.axis_steps_per_mm[AXIS_ID]));
+    }
+
     #if USE_SENSORLESS
       inline int16_t homing_threshold() { return TMC2209Stepper::SGTHRS(); }
       void homing_threshold(int16_t sgt_val) {
 
     #if HAS_LCD_MENU
       inline void refresh_stepper_current() { rms_current(this->val_mA); }
-
       #if ENABLED(HYBRID_THRESHOLD)
         inline void refresh_hybrid_thrs() { set_pwm_thrs(this->stored.hybrid_thrs); }
       #endif
 
 #endif // USE_SENSORLESS
 
-#if TMC_HAS_SPI
+#if HAS_TMC_SPI
   void tmc_init_cs_pins();
 #endif
 

Marlin/src/inc/SanityCheck.h

 #endif
 
 /**
+ * Make sure CoolStep settings exist
+ */
+#if HAS_COOLSTEP
+  #define NEEDS_COOLSTEP(A) AXIS_HAS_COOLSTEP(A) && !(defined(A##_COOLSTEP_SPEED_THRESHOLD) && defined(A##_COOLSTEP_LOWER_LOAD_THRESHOLD) && defined(A##_COOLSTEP_UPPER_LOAD_THRESHOLD) && defined(A##_COOLSTEP_SEUP) && defined(A##_COOLSTEP_SEDN) && defined(A##_COOLSTEP_SEIMIN))
+  #if NEEDS_COOLSTEP(X)
+    #error "X COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(X2)
+    #error "X2 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(Y)
+    #error "Y COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(Y2)
+    #error "Y2 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(Z)
+    #error "Z COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(Z2)
+    #error "Z2 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(Z3)
+    #error "Z3 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(Z4)
+    #error "Z4 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(E0)
+    #error "E0 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(E1)
+    #error "E1 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(E2)
+    #error "E2 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(E3)
+    #error "E3 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(E4)
+    #error "E4 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(E5)
+    #error "E5 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(E6)
+    #error "E6 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #if NEEDS_COOLSTEP(E7)
+    #error "E7 COOLSTEP settings must be defined in Configuration_adv.h."
+  #endif
+  #undef NEEDS_COOLSTEP
+#endif
+
+/**
  * Check existing CS pins against enabled TMC SPI drivers.
  */
 #define INVALID_TMC_SPI(ST) (AXIS_HAS_SPI(ST) && !PIN_EXISTS(ST##_CS))
  * Check to make sure MONITOR_DRIVER_STATUS isn't enabled
  * on boards where TMC drivers share the SPI bus with SD.
  */
-#if TMC_HAS_SPI && ALL(MONITOR_DRIVER_STATUS, SDSUPPORT, USES_SHARED_SPI)
+#if HAS_TMC_SPI && ALL(MONITOR_DRIVER_STATUS, SDSUPPORT, USES_SHARED_SPI)
   #error "MONITOR_DRIVER_STATUS and SDSUPPORT cannot be used together on boards with shared SPI."
 #endif

Marlin/src/module/stepper.cpp

     #define _APPLY_STEP(AXIS) AXIS ##_APPLY_STEP
     #define _INVERT_STEP_PIN(AXIS) INVERT_## AXIS ##_STEP_PIN
 
-    // Determine if pulses are needed
+    // Determine if a pulse is needed using Bresenham
     #define PULSE_PREP(AXIS) do{ \
       delta_error[_AXIS(AXIS)] += advance_dividend[_AXIS(AXIS)]; \
       step_needed[_AXIS(AXIS)] = (delta_error[_AXIS(AXIS)] >= 0); \

Marlin/src/module/stepper/trinamic.cpp

 #include <SPI.h>
 
 enum StealthIndex : uint8_t { STEALTH_AXIS_XY, STEALTH_AXIS_Z, STEALTH_AXIS_E };
-#define _TMC_INIT(ST, STEALTH_INDEX) tmc_init(stepper##ST, ST##_CURRENT, ST##_MICROSTEPS, ST##_HYBRID_THRESHOLD, stealthchop_by_axis[STEALTH_INDEX])
+#define _TMC_INIT_1(ST, STEALTH_INDEX) tmc_init(stepper##ST, ST##_CURRENT, ST##_MICROSTEPS)
+#define _TMC_INIT_2(ST, STEALTH_INDEX) tmc_init(stepper##ST, ST##_CURRENT, ST##_MICROSTEPS, stealthchop_by_axis[STEALTH_INDEX], ST##_HYBRID_THRESHOLD)
+#define _TMC_INIT_3(ST, STEALTH_INDEX) tmc_init(stepper##ST, ST##_CURRENT, ST##_MICROSTEPS, stealthchop_by_axis[STEALTH_INDEX], ST##_HYBRID_THRESHOLD, ST##_COOLSTEP_SPEED_THRESHOLD, ST##_COOLSTEP_LOWER_LOAD_THRESHOLD, ST##_COOLSTEP_UPPER_LOAD_THRESHOLD, ST##_COOLSTEP_SEUP, ST##_COOLSTEP_SEDN, ST##_COOLSTEP_SEIMIN)
+#define _TMC_INIT_TMC2660(ST, STEALTH_INDEX) _TMC_INIT_1(ST, STEALTH_INDEX)
+#define _TMC_INIT_TMC2160(ST, STEALTH_INDEX) _TMC_INIT_2(ST, STEALTH_INDEX)
+#define _TMC_INIT_TMC2208(ST, STEALTH_INDEX) _TMC_INIT_2(ST, STEALTH_INDEX)
+#define _TMC_INIT_TMC5130(ST, STEALTH_INDEX) _TMC_INIT_3(ST, STEALTH_INDEX)
+#define _TMC_INIT_TMC5160(ST, STEALTH_INDEX) _TMC_INIT_3(ST, STEALTH_INDEX)
+#define _TMC_INIT_TMC2130(ST, STEALTH_INDEX) _TMC_INIT_3(ST, STEALTH_INDEX)
+#define _TMC_INIT_TMC2209(ST, STEALTH_INDEX) _TMC_INIT_3(ST, STEALTH_INDEX)
+#define __TMC_INIT(DRV, ST, STEALTH_INDEX) _TMC_INIT_##DRV(ST, STEALTH_INDEX)
+#define _TMC_INIT(DRV, ST, STEALTH_INDEX) __TMC_INIT(DRV, ST, STEALTH_INDEX)
+#define TMC_INIT(ST, STEALTH_INDEX) _TMC_INIT(ST##_DRIVER_TYPE, ST, STEALTH_INDEX)
 
 //   IC = TMC model number
 //   ST = Stepper object letter
 
 #if HAS_DRIVER(TMC2130)
   template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
-  void tmc_init(TMCMarlin<TMC2130Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st, const uint16_t mA, const uint16_t microsteps, const uint32_t thrs, const bool stealth) {
+  void tmc_init(
+    TMCMarlin<TMC2130Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st,
+    const uint16_t mA,
+    const uint16_t microsteps,
+    const bool stealth,
+    const uint32_t hyb_thrs,
+    const uint32_t cool_thrs,
+    const uint8_t cool_semin,
+    const uint8_t cool_semax,
+    const uint8_t cool_seup,
+    const uint8_t cool_sedn,
+    const bool cool_seimin
+  ) {
     st.begin();
 
     CHOPCONF_t chopconf{0};
     st.PWMCONF(pwmconf.sr);
 
     #if ENABLED(HYBRID_THRESHOLD)
-      st.set_pwm_thrs(thrs);
+      st.set_pwm_thrs(hyb_thrs);
     #else
-      UNUSED(thrs);
+      UNUSED(hyb_thrs);
     #endif
 
+    st.set_cool_thrs(cool_thrs);  // (mm/s)
+    COOLCONF_t coolconf{0};
+    coolconf.semin = cool_semin;
+    coolconf.semax = cool_semax;
+    coolconf.seup = cool_seup;
+    coolconf.sedn = cool_sedn;
+    coolconf.seimin = cool_seimin;
+    st.COOLCONF(coolconf.sr);
+
     st.GSTAT(); // Clear GSTAT
   }
 #endif // TMC2130
 
 #if HAS_DRIVER(TMC2160)
   template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
-  void tmc_init(TMCMarlin<TMC2160Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st, const uint16_t mA, const uint16_t microsteps, const uint32_t thrs, const bool stealth) {
+  void tmc_init(
+    TMCMarlin<TMC2160Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st,
+    const uint16_t mA,
+    const uint16_t microsteps,
+    const bool stealth,
+    const uint32_t hyb_thrs
+  ) {
     st.begin();
 
     CHOPCONF_t chopconf{0};
     st.PWMCONF(pwmconf.sr);
 
     #if ENABLED(HYBRID_THRESHOLD)
-      st.set_pwm_thrs(thrs);
+      st.set_pwm_thrs(hyb_thrs);
     #else
-      UNUSED(thrs);
+      UNUSED(hyb_thrs);
     #endif
 
     st.GSTAT(); // Clear GSTAT
 
 #if HAS_DRIVER(TMC2208)
   template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
-  void tmc_init(TMCMarlin<TMC2208Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st, const uint16_t mA, const uint16_t microsteps, const uint32_t thrs, const bool stealth) {
+  void tmc_init(
+    TMCMarlin<TMC2208Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st,
+    const uint16_t mA,
+    const uint16_t microsteps,
+    const bool stealth,
+    const uint32_t hyb_thrs
+  ) {
     TMC2208_n::GCONF_t gconf{0};
     gconf.pdn_disable = true; // Use UART
     gconf.mstep_reg_select = true; // Select microsteps with UART
     st.PWMCONF(pwmconf.sr);
 
     #if ENABLED(HYBRID_THRESHOLD)
-      st.set_pwm_thrs(thrs);
+      st.set_pwm_thrs(hyb_thrs);
     #else
-      UNUSED(thrs);
+      UNUSED(hyb_thrs);
     #endif
 
     st.GSTAT(0b111); // Clear
 
 #if HAS_DRIVER(TMC2209)
   template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
-  void tmc_init(TMCMarlin<TMC2209Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st, const uint16_t mA, const uint16_t microsteps, const uint32_t thrs, const bool stealth) {
+  void tmc_init(
+    TMCMarlin<TMC2209Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st,
+    const uint16_t mA,
+    const uint16_t microsteps,
+    const bool stealth,
+    const uint32_t hyb_thrs,
+    const uint32_t cool_thrs,
+    const uint8_t cool_semin,
+    const uint8_t cool_semax,
+    const uint8_t cool_seup,
+    const uint8_t cool_sedn,
+    const bool cool_seimin
+  ) {
     TMC2208_n::GCONF_t gconf{0};
     gconf.pdn_disable = true; // Use UART
     gconf.mstep_reg_select = true; // Select microsteps with UART
     st.PWMCONF(pwmconf.sr);
 
     #if ENABLED(HYBRID_THRESHOLD)
-      st.set_pwm_thrs(thrs);
+      st.set_pwm_thrs(hyb_thrs);
     #else
-      UNUSED(thrs);
+      UNUSED(hyb_thrs);
     #endif
 
+    st.set_cool_thrs(cool_thrs);  // (mm/s)
+    COOLCONF_t coolconf{0};
+    coolconf.semin = cool_semin;
+    coolconf.semax = cool_semax;
+    coolconf.seup = cool_seup;
+    coolconf.sedn = cool_sedn;
+    coolconf.seimin = cool_seimin;
+    st.COOLCONF(coolconf.sr);
+
     st.GSTAT(0b111); // Clear
     delay(200);
   }
 
 #if HAS_DRIVER(TMC2660)
   template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
-  void tmc_init(TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st, const uint16_t mA, const uint16_t microsteps, const uint32_t, const bool) {
+  void tmc_init(
+    TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st,
+    const uint16_t mA,
+    const uint16_t microsteps
+  ) {
     st.begin();
 
     TMC2660_n::CHOPCONF_t chopconf{0};
 
 #if HAS_DRIVER(TMC5130)
   template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
-  void tmc_init(TMCMarlin<TMC5130Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st, const uint16_t mA, const uint16_t microsteps, const uint32_t thrs, const bool stealth) {
+  void tmc_init(
+    TMCMarlin<TMC5130Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st,
+    const uint16_t mA,
+    const uint16_t microsteps,
+    const bool stealth,
+    const uint32_t hyb_thrs,
+    const uint32_t cool_thrs,
+    const uint8_t cool_semin,
+    const uint8_t cool_semax,
+    const uint8_t cool_seup,
+    const uint8_t cool_sedn,
+    const bool cool_seimin
+  ) {
     st.begin();
 
     CHOPCONF_t chopconf{0};
     st.PWMCONF(pwmconf.sr);
 
     #if ENABLED(HYBRID_THRESHOLD)
-      st.set_pwm_thrs(thrs);
+      st.set_pwm_thrs(hyb_thrs);
     #else
-      UNUSED(thrs);
+      UNUSED(hyb_thrs);
     #endif
 
+    st.set_cool_thrs(cool_thrs);  // (mm/s)
+    COOLCONF_t coolconf{0};
+    coolconf.semin = cool_semin;
+    coolconf.semax = cool_semax;
+    coolconf.seup = cool_seup;
+    coolconf.sedn = cool_sedn;
+    coolconf.seimin = cool_seimin;
+    st.COOLCONF(coolconf.sr);
+
     st.GSTAT(); // Clear GSTAT
   }
 #endif // TMC5130
 
 #if HAS_DRIVER(TMC5160)
   template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
-  void tmc_init(TMCMarlin<TMC5160Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st, const uint16_t mA, const uint16_t microsteps, const uint32_t thrs, const bool stealth) {
+  void tmc_init(
+    TMCMarlin<TMC5160Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st,
+    const uint16_t mA,
+    const uint16_t microsteps,
+    const bool stealth,
+    const uint32_t hyb_thrs,
+    const uint32_t cool_thrs,
+    const uint8_t cool_semin,
+    const uint8_t cool_semax,
+    const uint8_t cool_seup,
+    const uint8_t cool_sedn,
+    const bool cool_seimin
+  ) {
     st.begin();
 
     CHOPCONF_t chopconf{0};
     st.PWMCONF(pwmconf.sr);
 
     #if ENABLED(HYBRID_THRESHOLD)
-      st.set_pwm_thrs(thrs);
+      st.set_pwm_thrs(hyb_thrs);
     #else
-      UNUSED(thrs);
+      UNUSED(hyb_thrs);
     #endif
+
+    st.set_cool_thrs(cool_thrs);  // (mm/s)
+    COOLCONF_t coolconf{0};
+    coolconf.semin = cool_semin;
+    coolconf.semax = cool_semax;
+    coolconf.seup = cool_seup;
+    coolconf.sedn = cool_sedn;
+    coolconf.seimin = cool_seimin;
+    st.COOLCONF(coolconf.sr);
+
     st.GSTAT(); // Clear GSTAT
   }
 #endif // TMC5160
   };
 
   #if AXIS_IS_TMC(X)
-    _TMC_INIT(X, STEALTH_AXIS_XY);
+    TMC_INIT(X, STEALTH_AXIS_XY);
   #endif
   #if AXIS_IS_TMC(X2)
-    _TMC_INIT(X2, STEALTH_AXIS_XY);
+    TMC_INIT(X2, STEALTH_AXIS_XY);
   #endif
   #if AXIS_IS_TMC(Y)
-    _TMC_INIT(Y, STEALTH_AXIS_XY);
+    TMC_INIT(Y, STEALTH_AXIS_XY);
   #endif
   #if AXIS_IS_TMC(Y2)
-    _TMC_INIT(Y2, STEALTH_AXIS_XY);
+    TMC_INIT(Y2, STEALTH_AXIS_XY);
   #endif
   #if AXIS_IS_TMC(Z)
-    _TMC_INIT(Z, STEALTH_AXIS_Z);
+    TMC_INIT(Z, STEALTH_AXIS_Z);
   #endif
   #if AXIS_IS_TMC(Z2)
-    _TMC_INIT(Z2, STEALTH_AXIS_Z);
+    TMC_INIT(Z2, STEALTH_AXIS_Z);
   #endif
   #if AXIS_IS_TMC(Z3)
-    _TMC_INIT(Z3, STEALTH_AXIS_Z);
+    TMC_INIT(Z3, STEALTH_AXIS_Z);
   #endif
   #if AXIS_IS_TMC(Z4)
-    _TMC_INIT(Z4, STEALTH_AXIS_Z);
+    TMC_INIT(Z4, STEALTH_AXIS_Z);
   #endif
   #if AXIS_IS_TMC(E0)
-    _TMC_INIT(E0, STEALTH_AXIS_E);
+    TMC_INIT(E0, STEALTH_AXIS_E);
   #endif
   #if AXIS_IS_TMC(E1)
-    _TMC_INIT(E1, STEALTH_AXIS_E);
+    TMC_INIT(E1, STEALTH_AXIS_E);
   #endif
   #if AXIS_IS_TMC(E2)
-    _TMC_INIT(E2, STEALTH_AXIS_E);
+    TMC_INIT(E2, STEALTH_AXIS_E);
   #endif
   #if AXIS_IS_TMC(E3)
-    _TMC_INIT(E3, STEALTH_AXIS_E);
+    TMC_INIT(E3, STEALTH_AXIS_E);
   #endif
   #if AXIS_IS_TMC(E4)
-    _TMC_INIT(E4, STEALTH_AXIS_E);
+    TMC_INIT(E4, STEALTH_AXIS_E);
   #endif
   #if AXIS_IS_TMC(E5)
-    _TMC_INIT(E5, STEALTH_AXIS_E);
+    TMC_INIT(E5, STEALTH_AXIS_E);
   #endif
   #if AXIS_IS_TMC(E6)
-    _TMC_INIT(E6, STEALTH_AXIS_E);
+    TMC_INIT(E6, STEALTH_AXIS_E);
   #endif
   #if AXIS_IS_TMC(E7)
-    _TMC_INIT(E7, STEALTH_AXIS_E);
+    TMC_INIT(E7, STEALTH_AXIS_E);
   #endif
 
   #if USE_SENSORLESS

Marlin/src/pins/lpc1768/pins_GMARSH_X6_REV1.h

 //
 // TMC2208 UART pins
 //
-#if HAS_DRIVER(TMC2208)
+#if HAS_TMC_UART
   #define X_SERIAL_TX_PIN  P1_00
   #define X_SERIAL_RX_PIN  P1_00
   #define Y_SERIAL_TX_PIN  P1_09

Marlin/src/pins/lpc1769/pins_TH3D_EZBOARD.h

 #define E1_DIR_PIN         P2_13
 #define E1_ENABLE_PIN      P4_29
 
-#if HAS_DRIVER(TMC2208)
+#if HAS_TMC_UART
   //
-  // TMC2208 stepper drivers
+  // TMC220x stepper drivers
   // Software serial
   //
   #define X_SERIAL_TX_PIN  P0_04

Marlin/src/pins/mega/pins_MIGHTYBOARD_REVE.h

 #define SD_DETECT_PIN       9   // H6
 
 //
-//TMC 2208
+// TMC 220x
 //
-#if HAS_DRIVER(TMC2208)
+#if HAS_TMC_UART
   /**
-   * TMC2208 stepper drivers
+   * TMC220x stepper drivers
    *
    * Hardware serial communication ports.
    * If undefined software serial is used according to the pins below

Marlin/src/pins/pins.h

 #define _PEXI(p,q) __PEXI(p,q)
 #define __EPIN(p,q) E##p##_##q##_PIN
 #define _EPIN(p,q) __EPIN(p,q)
+#define __EDRV(p) E##p##_DRIVER_TYPE
+#define _EDRV(p) __EDRV(p)
 #define DIAG_REMAPPED(p,q) (PIN_EXISTS(q) && _EPIN(p##_E_INDEX, DIAG) == q##_PIN)
 
 // The X2 axis, if any, should be the next open extruder port
 #define X2_E_INDEX E_STEPPERS
 
 #if EITHER(DUAL_X_CARRIAGE, X_DUAL_STEPPER_DRIVERS)
+  #ifndef X2_DRIVER_TYPE
+    #define X2_DRIVER_TYPE _EDRV(X2_E_INDEX)
+  #endif
+
   #ifndef X2_STEP_PIN
     #define X2_STEP_PIN   _EPIN(X2_E_INDEX, STEP)
     #define X2_DIR_PIN    _EPIN(X2_E_INDEX, DIR)
 
 // The Y2 axis, if any, should be the next open extruder port
 #if ENABLED(Y_DUAL_STEPPER_DRIVERS)
+  #ifndef Y2_DRIVER_TYPE
+    #define Y2_DRIVER_TYPE _EDRV(Y2_E_INDEX)
+  #endif
+
   #ifndef Y2_STEP_PIN
     #define Y2_STEP_PIN   _EPIN(Y2_E_INDEX, STEP)
     #define Y2_DIR_PIN    _EPIN(Y2_E_INDEX, DIR)
 
 // The Z2 axis, if any, should be the next open extruder port
 #if NUM_Z_STEPPER_DRIVERS >= 2
+  #ifndef Z2_DRIVER_TYPE
+    #define Z2_DRIVER_TYPE _EDRV(Z2_E_INDEX)
+  #endif
+
   #ifndef Z2_STEP_PIN
     #define Z2_STEP_PIN   _EPIN(Z2_E_INDEX, STEP)
     #define Z2_DIR_PIN    _EPIN(Z2_E_INDEX, DIR)
 #endif
 
 #if NUM_Z_STEPPER_DRIVERS >= 3
+  #ifndef Z3_DRIVER_TYPE
+    #define Z3_DRIVER_TYPE _EDRV(Z3_E_INDEX)
+  #endif
+
   #ifndef Z3_STEP_PIN
     #define Z3_STEP_PIN   _EPIN(Z3_E_INDEX, STEP)
     #define Z3_DIR_PIN    _EPIN(Z3_E_INDEX, DIR)
 #endif
 
 #if NUM_Z_STEPPER_DRIVERS >= 4
+  #ifndef Z4_DRIVER_TYPE
+    #define Z4_DRIVER_TYPE _EDRV(Z4_E_INDEX)
+  #endif
+
   #ifndef Z4_STEP_PIN
     #define Z4_STEP_PIN   _EPIN(Z4_E_INDEX, STEP)
     #define Z4_DIR_PIN    _EPIN(Z4_E_INDEX, DIR)

Marlin/src/pins/ramps/pins_Z_BOLT_X_SERIES.h

   #endif
 #endif
 
-#if HAS_DRIVER(TMC2208)
+#if HAS_TMC_UART
   /**
-   * TMC2208 stepper drivers
+   * TMC220x stepper drivers
    *
    * Hardware serial communication ports.
    * If undefined software serial is used according to the pins below

Marlin/src/pins/stm32/pins_BTT_SKR_MINI_E3_V1_0.h

 #define BOARD_INFO_NAME "BIGTREE SKR Mini E3"
 
 /**
- * TMC2209 stepper drivers
+ * TMC220x stepper drivers
  * Hardware serial communication ports.
  */
-#if HAS_DRIVER(TMC2209)
+#if HAS_TMC_UART
   #define X_HARDWARE_SERIAL  Serial4
   #define Y_HARDWARE_SERIAL  Serial4
   #define Z_HARDWARE_SERIAL  Serial4