btt stm32 CR6 Fixes

Upstream fixes
SKR2/3
2024-06-26 10:26:47 -04:00 · 2024-06-18 15:46:57 -04:00 · 2024-06-03 14:40:38 -04:00 · 2024-04-16 10:05:38 -04:00 · 2024-04-16 10:05:17 -04:00 · 2024-04-15 02:38:10 +00:00
532 changed files with 23588 additions and 4004 deletions
@@ -1,40 +0,0 @@
-#
-# Configuration for Lock Threads - https://github.com/dessant/lock-threads-app
-#
-
-# Number of days of inactivity before a closed issue or pull request is locked
-daysUntilLock: 60
-
-# Skip issues and pull requests created before a given timestamp. Timestamp must
-# follow ISO 8601 (`YYYY-MM-DD`). Set to `false` to disable
-skipCreatedBefore: false
-
-# Issues and pull requests with these labels will be ignored. Set to `[]` to disable
-exemptLabels: [ 'no-locking' ]
-
-# Label to add before locking, such as `outdated`. Set to `false` to disable
-lockLabel: false
-
-# Comment to post before locking. Set to `false` to disable
-lockComment: >
-  This thread has been automatically locked since there has not been
-  any recent activity after it was closed. Please open a new issue for
-  related bugs.
-
-# Assign `resolved` as the reason for locking. Set to `false` to disable
-setLockReason: true
-
-# Limit to only `issues` or `pulls`
-# only: issues
-
-# Optionally, specify configuration settings just for `issues` or `pulls`
-# issues:
-#   exemptLabels:
-#     - help-wanted
-#   lockLabel: outdated
-
-# pulls:
-#   daysUntilLock: 30
-
-# Repository to extend settings from
-# _extends: repo
@@ -19,7 +19,7 @@ jobs:
    steps:

    - name: Check out bugfix-2.0.x
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
      with:
        ref: bugfix-2.0.x

@@ -39,7 +39,7 @@ jobs:
        exit 0

    - name: Check out bugfix-2.1.x
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
      with:
        ref: bugfix-2.1.x

@@ -1,9 +1,9 @@
 #
-# test-builds.yml
+# ci-build-tests.yml
 # Do test builds to catch compile errors
 #

-name: CI
+name: CI - Build Tests

 on:
  pull_request:
@@ -27,7 +27,7 @@ on:

 jobs:
  test_builds:
-    name: Run All Tests
+    name: Build Test
    if: github.repository == 'MarlinFirmware/Marlin'

    runs-on: ubuntu-latest
@@ -152,7 +152,7 @@ jobs:
      uses: actions/checkout@v4

    - name: Cache pip
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
@@ -160,13 +160,13 @@ jobs:
          ${{ runner.os }}-pip-

    - name: Cache PlatformIO
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.platformio
        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}

    - name: Select Python 3.9
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
      with:
        python-version: '3.9'
        architecture: 'x64'
@@ -0,0 +1,73 @@
+#
+# ci-unit-tests.yml
+# Build and execute unit tests to catch functional issues in code
+#
+
+name: CI - Unit Tests
+
+on:
+  pull_request:
+    branches:
+    - bugfix-2.1.x
+    # Cannot be enabled on 2.1.x until it contains the unit test framework
+    #- 2.1.x
+    paths-ignore:
+    - config/**
+    - data/**
+    - docs/**
+    - '**/*.md'
+  push:
+    branches:
+    - bugfix-2.1.x
+    # Cannot be enabled on 2.1.x until it contains the unit test framework
+    #- 2.1.x
+    paths-ignore:
+    - config/**
+    - data/**
+    - docs/**
+    - '**/*.md'
+
+jobs:
+  # This runs all unit tests as a single job. While it should be possible to break this up into
+  # multiple jobs, they currently run quickly and finish long before the compilation tests.
+  run_unit_tests:
+    name: Unit Test
+    # These tests will only be able to run on the bugfix-2.1.x branch, until the next release
+    # pulls them into additional branches.
+    if: github.repository == 'MarlinFirmware/Marlin'
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out the PR
+      uses: actions/checkout@v4
+
+    - name: Cache pip
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+
+    - name: Cache PlatformIO
+      uses: actions/cache@v4
+      with:
+        path: ~/.platformio
+        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+
+    - name: Select Python 3.9
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.9'
+        architecture: 'x64'
+
+    - name: Install PlatformIO
+      run: |
+        pip install -U platformio
+        pio upgrade --dev
+        pio pkg update --global
+
+    - name: Run All Unit Tests
+      run: |
+        make unit-test-all-local
@@ -32,7 +32,7 @@ jobs:
          - "Needs: Work"

    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Remove Labels
        uses: actions-ecosystem/action-remove-labels@v1
        with:
@@ -17,7 +17,7 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-    - uses: actions/stale@v8
+    - uses: actions/stale@v9
      with:
        repo-token: ${{ secrets.GITHUB_TOKEN }}
        stale-issue-message: |
@@ -17,15 +17,15 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-    - uses: dessant/lock-threads@v2
+    - uses: dessant/lock-threads@v5
      with:
        github-token: ${{ github.token }}
        process-only: 'issues'
-        issue-lock-inactive-days: '60'
-        issue-exclude-created-before: ''
-        issue-exclude-labels: 'no-locking'
-        issue-lock-labels: ''
-        issue-lock-comment: >
+        issue-inactive-days: '60'
+        exclude-issue-created-before: ''
+        exclude-any-issue-labels: 'no-locking'
+        add-issue-labels: ''
+        issue-comment: >
          This issue has been automatically locked since there
          has not been any recent activity after it was closed.
          Please open a new issue for related bugs.
@@ -12,7 +12,12 @@ help:
 	@echo "make tests-single-local-docker : Run a single test locally, using docker"
 	@echo "make tests-all-local           : Run all tests locally"
 	@echo "make tests-all-local-docker    : Run all tests locally, using docker"
-	@echo "make setup-local-docker        : Build the local docker image"
+#	@echo "make unit-test-single-ci      : Run a single code test from inside the CI"
+#	@echo "make unit-test-single-local   : Run a single code test locally"
+#	@echo "make unit-test-single-local-docker : Run a single code test locally, using docker-compose"
+	@echo "make unit-test-all-local      : Run all code tests locally"
+	@echo "make unit-test-all-local-docker : Run all code tests locally, using docker-compose"
+	@echo "make setup-local-docker        : Setup local docker-compose"
 	@echo ""
 	@echo "Options for testing:"
 	@echo "  TEST_TARGET          Set when running tests-single-*, to select the"
@@ -43,7 +48,7 @@ tests-single-local:
 tests-single-local-docker:
 	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local-docker" ; return 1; fi
 	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
-	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
+	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) make tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"

 tests-all-local:
 	export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
@@ -52,10 +57,31 @@ tests-all-local:

 tests-all-local-docker:
 	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
-	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
+	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) make tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
+
+#unit-test-single-ci:
+#	export GIT_RESET_HARD=true
+#	$(MAKE) unit-test-single-local TEST_TARGET=$(TEST_TARGET)
+
+# TODO: How can we limit tests with ONLY_TEST with platformio?
+#unit-test-single-local:
+#	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make unit-test-all-local" ; return 1; fi
+#	platformio run -t marlin_$(TEST_TARGET)
+
+#unit-test-single-local-docker:
+#	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make unit-test-all-local-docker" ; return 1; fi
+#	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
+#	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS)  $(CONTAINER_IMAGE) make unit-test-single-local TEST_TARGET=$(TEST_TARGET) ONLY_TEST="$(ONLY_TEST)"
+
+unit-test-all-local:
+	platformio run -t test-marlin -e linux_native_test
+
+unit-test-all-local-docker:
+	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
+	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS)  $(CONTAINER_IMAGE) make unit-test-all-local

 setup-local-docker:
-	$(CONTAINER_RT_BIN) build -t $(CONTAINER_IMAGE) -f docker/Dockerfile .
+	$(CONTAINER_RT_BIN) buildx build -t $(CONTAINER_IMAGE) -f docker/Dockerfile .

 PINS := $(shell find Marlin/src/pins -mindepth 2 -name '*.h')

@@ -16,7 +16,7 @@
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 #pragma once
@@ -28,25 +28,177 @@
 /**
 * Marlin release version identifier
 */
-//#define SHORT_BUILD_VERSION "bugfix-2.1.x"
+#define SHORT_BUILD_VERSION "DW7.4.9"

 /**
 * Verbose version identifier which should contain a reference to the location
 * from where the binary was downloaded or the source code was compiled.
 */
-//#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION
+
+#if(ENABLED(MachineMini))
+  #define VerChar1 "M"
+#elif(ENABLED(MachineEnder2))
+  #define VerChar1 "E2"
+#elif(ENABLED(MachineEnder2Pro))
+  #define VerChar1 "E2P"
+#elif(ENABLED(MachineEnder3))
+  #define VerChar1 "E3"
+#elif ENABLED(MachineEnder3V2)
+  #define VerChar1 "E3V2"
+#elif ENABLED(MachineEnder3S1)
+  #define VerChar1 "E3S1"
+#elif ENABLED(MachineEnder3Max)
+  #define VerChar1 "E3M"
+#elif(ENABLED(MachineEnder4))
+  #define VerChar1 "E4"
+#elif(ENABLED(MachineEnder5))
+  #define VerChar1 "E5"
+#elif(ENABLED(MachineEnder6))
+  #define VerChar1 "E6"
+#elif(ENABLED(MachineEnder7))
+  #define VerChar1 "E7"
+#elif(ENABLED(MachineSermoonD1))
+  #define VerChar1 "D1"
+#elif(ENABLED(MachineEnder5Plus))
+  #define VerChar1 "E5P"
+#elif(ENABLED(MachineCR20))
+  #define VerChar1 "2"
+#elif(ENABLED(MachineCR10Orig))
+  #define VerChar1 "O"
+#elif(ENABLED(MachineCR10Std))
+  #define VerChar1 "S"
+#elif(ENABLED(MachineCRX))
+  #define VerChar1 "X"
+#elif(ENABLED(MachineCR6))
+  #define VerChar1 "CR6"
+#elif(ENABLED(MachineCR5))
+  #define VerChar1 "CR5"
+#elif(ENABLED(MachineCR6Max))
+  #define VerChar1 "CR6M"
+#elif(ENABLED(MachineS4))
+  #define VerChar1 "4"
+#elif(ENABLED(MachineS5) || ENABLED(MachineCR10Max))
+  #define VerChar1 "5"
+#elif ENABLED(MachineCR2020)
+  #define VerChar1 "20"
+#elif(ENABLED(MachineCR30))
+  #define VerChar1 "CR30"
+#endif
+
+#if(ENABLED(HotendStock))
+#define VerChar2 "S"
+#elif(ENABLED(HotendE3D))
+#define VerChar2 "E"
+#elif ENABLED(HotendMosquito)
+#define VerChar2 "M"
+#endif
+
+#if(ENABLED(HotendAllMetal))
+#define VerChar3 "M"
+#else
+#define VerChar3 "S"
+#endif
+
+
+#if(ENABLED(BedAC))
+#define VerChar4 "A"
+#elif(ENABLED(BedDC))
+#define VerChar4 "D"
+#else
+#define VerChar4 "N"
+#endif
+
+#if(ENABLED(ABL_EZABL))
+#define VerChar5 "A"
+#elif(ENABLED(ABL_BLTOUCH))
+#define VerChar5 "B"
+#else
+#define VerChar5 "N"
+#endif
+
+#if(ENABLED(ABL_UBL))
+#define VerChar6 "U"
+#elif(ENABLED(ABL_BI))
+#define VerChar6 "B"
+#else
+#define VerChar6 "N"
+#endif
+
+#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION " TM3D " VerChar1 VerChar2 VerChar3 VerChar4 VerChar5 VerChar6

 /**
 * The STRING_DISTRIBUTION_DATE represents when the binary file was built,
 * here we define this default string as the date where the latest release
 * version was tagged.
 */
-//#define STRING_DISTRIBUTION_DATE "2024-01-31"
+#define STRING_DISTRIBUTION_DATE "2024-04-08"

 /**
 * Defines a generic printer name to be output to the LCD after booting Marlin.
 */
-//#define MACHINE_NAME "3D Printer"
+#if(ENABLED(MachineMini))
+  #define CUSTOM_MACHINE_NAME "Mini SuPeR"
+#elif(ENABLED(MachineCR10Smart))
+  #define CUSTOM_MACHINE_NAME "TM3D CR10Smart"
+#elif(ENABLED(MachineCR10SmartPro))
+  #define CUSTOM_MACHINE_NAME "TM3D CR10SmartPro"
+#elif(ENABLED(MachineEnder2))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender2"
+#elif(ENABLED(MachineEnder2Pro))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender2 Pro"
+#elif(ENABLED(MachineEnder3))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender3"
+#elif(ENABLED(MachineEnder3Max))
+  #define CUSTOM_MACHINE_NAME "TM3D E3Max"
+#elif(ENABLED(MachineEnder6))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender6"
+#elif(ENABLED(MachineEnder7))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender7"
+#elif(ENABLED(MachineEnder3V2))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender3V2"
+#elif(ENABLED(MachineEnder3S1))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender3S1"
+#elif(ENABLED(MachineEnder4))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender4"
+#elif(ENABLED(MachineEnder5))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender5"
+#elif(ENABLED(MachineEnder5Plus))
+  #define CUSTOM_MACHINE_NAME "TM3D E5 Plus"
+#elif(ENABLED(MachineCR20))
+  #define CUSTOM_MACHINE_NAME "SuPeR CR-20"
+#elif(ENABLED(MachineCR10Orig))
+  #define CUSTOM_MACHINE_NAME "SuPeR CR-10"
+#elif(ENABLED(MachineCRX))
+  #define CUSTOM_MACHINE_NAME "TM3D CR-X"
+#elif ENABLED(MachineCR10SProV2)
+  #define CUSTOM_MACHINE_NAME "TM3D 10SProV2"
+#elif(ENABLED(MachineCR10SPro))
+  #define CUSTOM_MACHINE_NAME "TM3D 10S Pro"
+#elif(ENABLED(MachineCR10Max))
+  #define CUSTOM_MACHINE_NAME "TM3D Max"
+#elif(ENABLED(MachineCR10SV3))
+  #define CUSTOM_MACHINE_NAME "TM3D CR10V3"
+#elif(ENABLED(MachineCR10SV2))
+  #define CUSTOM_MACHINE_NAME "TM3D CR10V2"
+#elif(ENABLED(MachineCR10Std))
+  #define CUSTOM_MACHINE_NAME "300 SuPeR"
+#elif(ENABLED(MachineS4))
+  #define CUSTOM_MACHINE_NAME "400 SuPeR"
+#elif(ENABLED(MachineS5))
+  #define CUSTOM_MACHINE_NAME "500 SuPeR"
+#elif ENABLED(MachineCR2020)
+  #define CUSTOM_MACHINE_NAME "TM3D 2020"
+#elif ENABLED(MachineSermoonD1)
+  #define CUSTOM_MACHINE_NAME "SermoonD1"
+#elif ENABLED(MachineCR5)
+  #define CUSTOM_MACHINE_NAME "CR5 Pro"
+#elif ENABLED(MachineCR6)
+  #define CUSTOM_MACHINE_NAME "CR6"
+#elif ENABLED(MachineCR6Max)
+  #define CUSTOM_MACHINE_NAME "CR6 Max"
+#elif ENABLED(MachineCR30)
+  #define CUSTOM_MACHINE_NAME "CR30 Printmill"
+#endif

 /**
 * The SOURCE_CODE_URL is the location where users will find the Marlin Source
@@ -54,7 +206,7 @@
 * has a distinct Github fork— the Source Code URL should just be the main
 * Marlin repository.
 */
-//#define SOURCE_CODE_URL "github.com/MarlinFirmware/Marlin"
+#define SOURCE_CODE_URL "https://github.com/InsanityAutomation/Marlin/tree/CrealityDwin_2.0"

 /**
 * Default generic printer UUID.
@@ -65,12 +217,12 @@
 * The WEBSITE_URL is the location where users can get more information such as
 * documentation about a specific Marlin release.
 */
-//#define WEBSITE_URL "marlinfw.org"
+#define WEBSITE_URL "tinymachines3d.com"

 /**
 * Set the vendor info the serial USB interface, if changable
 * Currently only supported by DUE platform
 */
-//#define USB_DEVICE_VENDOR_ID           0x0000
-//#define USB_DEVICE_PRODUCT_ID          0x0000
-//#define USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
+//#define  USB_DEVICE_VENDOR_ID           0x0000
+//#define  USB_DEVICE_PRODUCT_ID          0x0000
+//#define  USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
@@ -0,0 +1,93 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Custom Bitmap for splashscreen
+ *
+ * You may use one of the following tools to generate the C++ bitmap array from
+ * a black and white image:
+ *
+ *  - http://www.marlinfw.org/tools/u8glib/converter.html
+ *  - http://www.digole.com/tools/PicturetoC_Hex_converter.php
+ */
+
+#define CUSTOM_BOOTSCREEN_TIMEOUT   2500
+#define CUSTOM_BOOTSCREEN_BMPWIDTH  128
+#define CUSTOM_BOOTSCREEN_INVERTED
+
+const unsigned char custom_start_bmp[] PROGMEM = {
+  B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,
+  B11111110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,
+  B11111100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
+  B11111100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
+  B11111100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000000,B00000001,B11110000,B00111111,
+  B11111110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000000,B00000010,B00001000,B00011111,
+  B11111100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000000,B00000101,B00000100,B00111111,
+  B11111110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000000,B00001010,B00000010,B00011111,
+  B11111100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000000,B00010101,B00000001,B00111111,
+  B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
+  B11111100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000000,B00010100,B00000001,B00111111,
+  B11111110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
+  B11111100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B00010101,B00000001,B00111111,
+  B11111110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101010,B00001010,B00000010,B00011111,
+  B11111100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010001,B00000101,B00000100,B00111111,
+  B11111110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100001,B00000010,B10001000,B00011111,
+  B11111100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010001,B00000001,B11110000,B00111111,
+  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101010,B00000000,B00000000,B00011111,
+  B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00000000,B00000000,B00111111,
+  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
+  B11111100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
+  B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
+  B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
+  B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11100000,B00101110,B11111011,B01111101,B11111011,B11111011,B11001111,B11000001,B11011111,B10111011,B00111110,B11000000,B11100001,B11111110,B00111100,B00011111,
+  B11111101,B11101110,B01111011,B00111001,B11111001,B11110011,B11001111,B10011110,B11011111,B10111011,B00111110,B11011111,B11011110,B11111100,B11011101,B11100111,
+  B11111101,B11101110,B00111011,B10111011,B11111001,B11101011,B11010111,B10111111,B01011111,B10111011,B01011110,B11011111,B11011110,B11111101,B11101101,B11110111,
+  B11111101,B11101110,B10111011,B11010011,B11111010,B11101011,B10110111,B00111111,B11011111,B10111011,B01001110,B11011111,B11011111,B11111111,B11001101,B11110011,
+  B11111101,B11101110,B11011011,B11000111,B11111010,B11101011,B10111011,B01111111,B11000000,B00111011,B01101110,B11000000,B11100011,B11111111,B00011101,B11110011,
+  B11111101,B11101110,B11001011,B11101111,B11111010,B11011011,B10111011,B01111111,B11011111,B10111011,B01100110,B11011111,B11111000,B11111111,B11001101,B11110011,
+  B11111101,B11101110,B11101011,B11101111,B11111011,B01011011,B00000011,B00111111,B01011111,B10111011,B01110110,B11011111,B11111110,B01111111,B11101101,B11110011,
+  B11111101,B11101110,B11110011,B11101111,B11111011,B01011011,B01111001,B10111110,B11011111,B10111011,B01111010,B11011111,B11011110,B01111101,B11101101,B11110111,
+  B11111101,B11101110,B11110011,B11101111,B11111011,B10111010,B11111101,B10011110,B11011111,B10111011,B01111100,B11011111,B11011110,B11111101,B11001101,B11100111,
+  B11111101,B11101110,B11111011,B11101111,B11111011,B10111010,B11111101,B11000001,B11011111,B10111011,B01111110,B11000000,B11100000,B11111110,B00011100,B00011111
+};
@@ -0,0 +1,74 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Custom Status Screen bitmap
+ *
+ * Place this file in the root with your configuration files
+ * and enable CUSTOM_STATUS_SCREEN_IMAGE in Configuration.h.
+ *
+ * Use the Marlin Bitmap Converter to make your own:
+ * http://marlinfw.org/tools/u8glib/converter.html
+ */
+
+//
+// Status Screen Logo bitmap
+//
+#define STATUS_LOGO_Y            3
+#define STATUS_LOGO_WIDTH       24
+
+const unsigned char status_logo_bmp[] PROGMEM = {
+  B11111111,B11111111,B11111111,
+  B10000000,B00000000,B00000001,
+  B10001110,B00000000,B11100001,
+  B10011111,B00000001,B11110001,
+  B10010011,B10000001,B00111001,
+  B10011111,B10000001,B11111001,
+  B10011111,B10000001,B11111001,
+  B10011111,B10111001,B11111001,
+  B10001111,B00101000,B11110001,
+  B10000000,B00111000,B00000001,
+  B10000000,B00000000,B00000001,
+  B10011111,B11111111,B11111001,
+  B10010001,B01110100,B10011001,
+  B10011011,B00000110,B10101001,
+  B10011011,B01010100,B10101001,
+  B10011011,B01010110,B10101001,
+  B10011011,B01010100,B10011001,
+  B10011111,B11111111,B11111001,
+  B11111111,B11111111,B11111111
+};
+
+//
+// Use default bitmaps
+//
+#define STATUS_HOTEND_ANIM
+#define STATUS_BED_ANIM
+#if HOTENDS < 2
+  #define STATUS_LOGO_X          8
+  #define STATUS_HEATERS_X      40
+  #define STATUS_BED_X          72
+#else
+  #define STATUS_LOGO_X          0
+  #define STATUS_HEATERS_X      32
+  #define STATUS_BED_X          80
+#endif
@@ -141,8 +141,8 @@ typedef Servo hal_servo_t;
    #error "LCD_SERIAL_PORT must be from 0 to 3."
  #endif
  #define LCD_SERIAL lcdSerial
-  #if HAS_DGUS_LCD
-    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
+    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
  #endif
 #endif

@@ -629,7 +629,7 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
  template class MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> >;
  MSerialLCD lcdSerial(MSerialLCD::HasEmergencyParser);

-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
    template<typename Cfg>
    typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::get_tx_buffer_free() {
      const ring_buffer_pos_t t = tx_buffer.tail,  // next byte to send.
@@ -205,7 +205,7 @@
    static ring_buffer_pos_t available();
    static void write(const uint8_t c);
    static void flushTX();
-    #if HAS_DGUS_LCD
+    #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
      static ring_buffer_pos_t get_tx_buffer_free();
    #endif

@@ -276,7 +276,7 @@
    static constexpr bool DROPPED_RX        = false;
    static constexpr bool RX_FRAMING_ERRORS = false;
    static constexpr bool MAX_RX_QUEUED     = false;
-    static constexpr bool RX_OVERRUNS       = ALL(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
+    static constexpr bool RX_OVERRUNS       = (ANY(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS) || ENABLED(DWINOS_4));
  };

  typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialLCD;
@@ -123,6 +123,11 @@ void MarlinHAL::init() {

  // Register min serial
  TERN_(POSTMORTEM_DEBUGGING, install_min_serial());
+
+  // warn if low memory after init
+  if (freeMemory() < 1024) {
+    SERIAL_WARN_MSG("HAL: low memory after init!\n");
+  }
 }

 void MarlinHAL::init_board() {}
@@ -147,7 +152,31 @@ void MarlinHAL::delay_ms(const int ms) {
  delay(ms);
 }

-void MarlinHAL::idletask() {}
+void MarlinHAL::idletask() {
+  #if ENABLED(MARLIN_DEV_MODE)
+    // check & print serial RX errors
+    MSerialT *serials[] = { &MSerial1, &MSerial2 };
+    for (int serial = 0; serial < 2; serial++) {
+      usart_receive_error_t err = serials[serial]->getReceiveError();
+      if (err != usart_receive_error_t::None) {
+        // "Warning: MSerial[n] RX [Framing|Parity|Overrun] Error"
+        SERIAL_WARN_START();
+        SERIAL_ECHOPGM(" MSerial");
+        SERIAL_ECHO(serial + 1);
+        SERIAL_ECHOPGM(" RX ");
+        switch(err) {
+          case usart_receive_error_t::FramingError: SERIAL_ECHOPGM("Framing"); break;
+          case usart_receive_error_t::ParityError:  SERIAL_ECHOPGM("Parity");  break;
+          case usart_receive_error_t::OverrunError: SERIAL_ECHOPGM("Overrun"); break;
+          case usart_receive_error_t::RxDataDropped: SERIAL_ECHOPGM("DataDropped"); break;
+          default: break;
+        }
+        SERIAL_ECHOPGM(" Error");
+        SERIAL_EOL();
+      }
+    }
+  #endif
+}

 uint8_t MarlinHAL::get_reset_source() {
  // Query reset cause from RMU
@@ -46,14 +46,34 @@ constexpr bool serial_handles_emergency(int port) {
 //
 // Define serial ports
 //
-#define DEFINE_HWSERIAL_MARLIN(name, n)      \
+
+// serial port where RX and TX use IRQs
+#define DEFINE_IRQ_SERIAL_MARLIN(name, n)      \
  MSerialT name(serial_handles_emergency(n), \
                &USART##n##_config,          \
                BOARD_USART##n##_TX_PIN,     \
                BOARD_USART##n##_RX_PIN);

-DEFINE_HWSERIAL_MARLIN(MSerial1, 1);
-DEFINE_HWSERIAL_MARLIN(MSerial2, 2);
+// serial port where RX uses DMA and TX uses IRQs
+// all serial ports use DMA1
+// since there are 4 USARTs and 4 DMA channels, we can use the USART number as the DMA channel
+#define DEFINE_DMA_SERIAL_MARLIN(name, n)      \
+  MSerialT name(serial_handles_emergency(n), \
+                &USART##n##_config,          \
+                BOARD_USART##n##_TX_PIN,     \
+                BOARD_USART##n##_RX_PIN,     \
+                M4_DMA1,                     \
+                ((en_dma_channel_t)(n - 1))); // map USART1 to DMA channel 0, USART2 to DMA channel 1, etc.
+
+#define DEFINE_SERIAL_MARLIN(name, n) TERN(SERIAL_DMA, DEFINE_DMA_SERIAL_MARLIN(name, n), DEFINE_IRQ_SERIAL_MARLIN(name, n))
+
+DEFINE_SERIAL_MARLIN(MSerial1, 1);
+DEFINE_SERIAL_MARLIN(MSerial2, 2);
+
+// TODO: remove this warning when SERIAL_DMA has been tested some more
+#if ENABLED(SERIAL_DMA)
+  #warning "SERIAL_DMA may be unstable on HC32F460."
+#endif

 //
 // Serial port assertions
@@ -25,17 +25,42 @@
 #include <drivers/usart/Usart.h>

 // Optionally set uart IRQ priority to reduce overflow errors
-// #define UART_IRQ_PRIO 1
+//#define UART_RX_IRQ_PRIO 1
+//#define UART_TX_IRQ_PRIO 1
+//#define UART_RX_DMA_IRQ_PRIO 1

 struct MarlinSerial : public Usart {
-  MarlinSerial(struct usart_config_t *usart_device, gpio_pin_t tx_pin, gpio_pin_t rx_pin) : Usart(usart_device, tx_pin, rx_pin) {}
+  MarlinSerial(
+    struct usart_config_t *usart_device, 
+    gpio_pin_t tx_pin, 
+    gpio_pin_t rx_pin
+    #if ENABLED(SERIAL_DMA)
+    , M4_DMA_TypeDef *dma_unit = nullptr,
+    en_dma_channel_t rx_dma_channel = DmaCh0
+    #endif
+  ) : Usart(usart_device, tx_pin, rx_pin) {
+    #if ENABLED(SERIAL_DMA)
+      if (dma_unit != nullptr) {
+        enableRxDma(dma_unit, rx_dma_channel);
+      }
+    #endif
+  }

-  #ifdef UART_IRQ_PRIO
+  #if defined(UART_RX_IRQ_PRIO) || defined(UART_TX_IRQ_PRIO) || defined(UART_RX_DMA_IRQ_PRIO)
    void setPriority() {
-      NVIC_SetPriority(c_dev()->interrupts.rx_data_available.interrupt_number, UART_IRQ_PRIO);
-      NVIC_SetPriority(c_dev()->interrupts.rx_error.interrupt_number, UART_IRQ_PRIO);
-      NVIC_SetPriority(c_dev()->interrupts.tx_buffer_empty.interrupt_number, UART_IRQ_PRIO);
-      NVIC_SetPriority(c_dev()->interrupts.tx_complete.interrupt_number, UART_IRQ_PRIO);
+      #if defined(UART_RX_IRQ_PRIO)
+        NVIC_SetPriority(c_dev()->interrupts.rx_data_available.interrupt_number, UART_RX_IRQ_PRIO);
+        NVIC_SetPriority(c_dev()->interrupts.rx_error.interrupt_number, UART_RX_IRQ_PRIO);
+      #endif
+
+      #if defined(UART_TX_IRQ_PRIO)
+        NVIC_SetPriority(c_dev()->interrupts.tx_buffer_empty.interrupt_number, UART_TX_IRQ_PRIO);
+        NVIC_SetPriority(c_dev()->interrupts.tx_complete.interrupt_number, UART_TX_IRQ_PRIO);
+      #endif
+
+      #if defined(UART_RX_DMA_IRQ_PRIO) && ENABLED(SERIAL_DMA)
+        NVIC_SetPriority(c_dev()->dma.rx.rx_data_available_dma_btc.interrupt_number, UART_RX_DMA_IRQ_PRIO);
+      #endif
    }

    void begin(uint32_t baud) {
@@ -47,7 +72,12 @@ struct MarlinSerial : public Usart {
      Usart::begin(baud, config);
      setPriority();
    }
-  #endif
+
+    void begin(uint32_t baud, const stc_usart_uart_init_t *config, const bool rxNoiseFilter = true) {
+      Usart::begin(baud, config, rxNoiseFilter);
+      setPriority();
+    }
+  #endif // UART_RX_IRQ_PRIO || UART_TX_IRQ_PRIO || UART_RX_DMA_IRQ_PRIO
 };

 typedef Serial1Class<MarlinSerial> MSerialT;
@@ -0,0 +1,70 @@
+/**
+ * app_config.h is included by the hc32f460 arduino build script for every source file.
+ * it is used to configure the arduino core (and ddl) automatically according 
+ * to the settings in Configuration.h and Configuration_adv.h.
+ */
+#pragma once
+#ifndef _HC32_APP_CONFIG_H_
+#define _HC32_APP_CONFIG_H_
+
+#include "../../inc/MarlinConfigPre.h"
+
+//
+// dev mode
+//
+#if ENABLED(MARLIN_DEV_MODE)
+  #define __DEBUG 1
+  #define __CORE_DEBUG 1
+#endif
+
+//
+// Fault Handlers and Panic
+//
+
+#if ENABLED(POSTMORTEM_DEBUGGING)
+  // disable arduino core fault handler, as we define our own
+  #define CORE_DISABLE_FAULT_HANDLER 1
+#endif
+
+// force-enable panic handler so that we can use our custom one (in MinSerial)
+#define PANIC_ENABLE 1
+
+// use short filenames in ddl debug and core panic output
+#define __DEBUG_SHORT_FILENAMES 1
+#define __PANIC_SHORT_FILENAMES 1
+
+// omit panic messages in core panic output
+#define __OMIT_PANIC_MESSAGE 1
+
+//
+// Usart
+//
+
+// disable serial globals (Serial1, Serial2, ...), as we define our own
+#define DISABLE_SERIAL_GLOBALS 1
+
+// increase the size of the Usart buffers (both RX and TX)
+// NOTE: 
+// the heap usage will increase by (SERIAL_BUFFER_SIZE - 64) * "number of serial ports used"
+// if running out of heap, the system may become unstable
+//#define SERIAL_BUFFER_SIZE 256
+
+// enable support for Usart Clock Divider / Oversampling auto config
+#define USART_AUTO_CLKDIV_OS_CONFIG 1
+
+// enable USART_RX_DMA_SUPPORT core option when SERIAL_DMA is enabled
+#if ENABLED(SERIAL_DMA)
+  #define USART_RX_DMA_SUPPORT 1
+#endif
+
+//
+// Misc.
+//
+
+// redirect printf to host serial
+#define REDIRECT_PRINTF_TO_SERIAL 1
+
+// FIXME override F_CPU to PCLK1, as marlin freaks out otherwise
+#define F_CPU (SYSTEM_CLOCK_FREQUENCIES.pclk1)
+
+#endif // _HC32_APP_CONFIG_H_
@@ -40,9 +40,15 @@ void endstopIRQHandler() {
  CHECK(X_MAX);
  CHECK(X_MIN);

+  CHECK(X2_MAX);
+  CHECK(X2_MIN);
+
  CHECK(Y_MAX);
  CHECK(Y_MIN);

+  CHECK(Y2_MAX);
+  CHECK(Y2_MIN);
+
  CHECK(Z_MAX);
  CHECK(Z_MIN);

@@ -52,6 +58,9 @@ void endstopIRQHandler() {
  CHECK(Z3_MAX);
  CHECK(Z3_MIN);

+  CHECK(Z4_MAX);
+  CHECK(Z4_MIN);
+
  CHECK(Z_MIN_PROBE);

  // Update endstops
@@ -69,9 +78,15 @@ void setup_endstop_interrupts() {
  SETUP(X_MAX);
  SETUP(X_MIN);

+  SETUP(X2_MAX);
+  SETUP(X2_MIN);
+
  SETUP(Y_MAX);
  SETUP(Y_MIN);

+  SETUP(Y2_MAX);
+  SETUP(Y2_MIN);
+
  SETUP(Z_MAX);
  SETUP(Z_MIN);

@@ -81,6 +96,9 @@ void setup_endstop_interrupts() {
  SETUP(Z3_MAX);
  SETUP(Z3_MIN);

+  SETUP(Z4_MAX);
+  SETUP(Z4_MIN);
+
  SETUP(Z_MIN_PROBE);

  #undef SETUP
@@ -88,7 +106,7 @@ void setup_endstop_interrupts() {

 // Ensure 1 - 10 IRQs are registered
 // Disable some endstops if you encounter this error
-#define ENDSTOPS_INTERRUPTS_COUNT COUNT_ENABLED(USE_X_MAX, USE_X_MIN, USE_Y_MAX, USE_Y_MIN, USE_Z_MAX, USE_Z_MIN, USE_Z2_MAX, USE_Z2_MIN, USE_Z3_MAX, USE_Z3_MIN, USE_Z_MIN_PROBE)
+#define ENDSTOPS_INTERRUPTS_COUNT COUNT_ENABLED(USE_X_MAX, USE_X_MIN, USE_X2_MAX, USE_X2_MIN, USE_Y_MAX, USE_Y_MIN, USE_Y2_MAX, USE_Y2_MIN, USE_Z_MAX, USE_Z_MIN, USE_Z2_MAX, USE_Z2_MIN, USE_Z3_MAX, USE_Z3_MIN, USE_Z4_MAX, USE_Z4_MIN, USE_Z_MIN_PROBE)
 #if ENDSTOPS_INTERRUPTS_COUNT > 10
  #error "Too many endstop interrupts! HC32F460 only supports 10 endstop interrupts."
 #elif ENDSTOPS_INTERRUPTS_COUNT == 0
@@ -20,6 +20,20 @@
 *
 */
 #pragma once
+#include <core_util.h>
+
+#if !defined(ARDUINO_CORE_VERSION_INT) || !defined(GET_VERSION_INT)
+  // version macros were introduced in arduino core version 1.1.0
+  // below that version, we polyfill them
+  #define GET_VERSION_INT(major, minor, patch) ((major * 100000) + (minor * 1000) + patch)
+  #define ARDUINO_CORE_VERSION_INT GET_VERSION_INT(1, 0, 0)
+#endif
+
+#if ARDUINO_CORE_VERSION_INT < GET_VERSION_INT(1, 1, 0)
+  // because we use app_config.h introduced in arduino core version 1.1.0, the 
+  // HAL is not compatible with older versions
+  #error "The HC32 HAL is not compatible with Arduino Core versions < 1.1.0. Consider updating the Arduino Core."
+#endif

 #ifndef BOARD_XTAL_FREQUENCY
  #error "BOARD_XTAL_FREQUENCY is required for HC32F460."
@@ -74,3 +88,18 @@
    #error "HC32 HAL uses a custom panic handler. Do not define PANIC_USARTx_TX_PIN."
  #endif
 #endif
+
+#if ENABLED(SERIAL_DMA)
+  #if !defined(USART_RX_DMA_SUPPORT)
+    #error "SERIAL_DMA requires USART_RX_DMA_SUPPORT to be enabled in the arduino core."
+  #endif
+
+  // USART_RX_DMA_SUPPORT does not implement core_hook_usart_rx_irq, which is required for the emergency parser
+  #if ENABLED(EMERGENCY_PARSER)
+    #error "EMERGENCY_PARSER is not supported with SERIAL_DMA. Please disable either SERIAL_DMA or EMERGENCY_PARSER."
+  #endif
+
+  #if ARDUINO_CORE_VERSION_INT < GET_VERSION_INT(1, 1, 0)
+    #error "SERIAL_DMA is not supported with arduino core version < 1.1.0."
+  #endif
+#endif
@@ -54,7 +54,7 @@
    fn                                              \
  }

-stc_sd_handle_t *handle;
+stc_sd_handle_t *handle = nullptr;

 bool SDIO_Init() {
  // Configure SDIO pins
@@ -66,36 +66,45 @@ bool SDIO_Init() {
  GPIO_SetFunc(BOARD_SDIO_CMD, Func_Sdio);
  GPIO_SetFunc(BOARD_SDIO_DET, Func_Sdio);

+  // If a handle is already initialized, free it before creating a new one
+  // otherwise, we will leak memory, which will eventually crash the system
+  if (handle != nullptr) {
+    delete handle->pstcDmaInitCfg;
+    delete handle->pstcCardInitCfg;
+    delete handle;
+    handle = nullptr;
+  }
+
  // Create DMA configuration
  stc_sdcard_dma_init_t *dmaConf = new stc_sdcard_dma_init_t;
  dmaConf->DMAx = SDIO_DMA_PERIPHERAL;
  dmaConf->enDmaCh = SDIO_DMA_CHANNEL;

+  // Create card configuration
+  // This should be a fairly safe configuration for most cards
+  stc_sdcard_init_t *cardConf = new stc_sdcard_init_t;
+  cardConf->enBusWidth = SdiocBusWidth4Bit;
+  cardConf->enClkFreq = SdiocClk400K;
+  cardConf->enSpeedMode = SdiocNormalSpeedMode;
+  cardConf->pstcInitCfg = nullptr;
+
  // Create handle in DMA mode
  handle = new stc_sd_handle_t;
  handle->SDIOCx = SDIO_PERIPHERAL;
  handle->enDevMode = SdCardDmaMode;
  handle->pstcDmaInitCfg = dmaConf;
-
-  // Create card configuration
-  // This should be a fairly safe configuration for most cards
-  stc_sdcard_init_t cardConf = {
-    .enBusWidth = SdiocBusWidth4Bit,
-    .enClkFreq = SdiocClk400K,
-    .enSpeedMode = SdiocNormalSpeedMode,
-    //.pstcInitCfg = NULL,
-  };
+  //handle->pstcCardInitCfg = cardConf; // assigned in SDCARD_Init

  // Initialize sd card
-  en_result_t rc = SDCARD_Init(handle, &cardConf);
+  en_result_t rc = SDCARD_Init(handle, cardConf);
  if (rc != Ok) printf("SDIO_Init() error (rc=%u)\n", rc);

  return rc == Ok;
 }

 bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
-  CORE_ASSERT(handle != NULL, "SDIO not initialized");
-  CORE_ASSERT(dst != NULL, "SDIO_ReadBlock dst is NULL");
+  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
+  CORE_ASSERT(dst != nullptr, "SDIO_ReadBlock dst is NULL", return false);

  WITH_RETRY(SDIO_READ_RETRIES, {
    en_result_t rc = SDCARD_ReadBlocks(handle, block, 1, dst, SDIO_READ_TIMEOUT);
@@ -107,8 +116,8 @@ bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
 }

 bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
-  CORE_ASSERT(handle != NULL, "SDIO not initialized");
-  CORE_ASSERT(src != NULL, "SDIO_WriteBlock src is NULL");
+  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
+  CORE_ASSERT(src != nullptr, "SDIO_WriteBlock src is NULL", return false);

  WITH_RETRY(SDIO_WRITE_RETRIES, {
    en_result_t rc = SDCARD_WriteBlocks(handle, block, 1, (uint8_t *)src, SDIO_WRITE_TIMEOUT);
@@ -120,12 +129,12 @@ bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
 }

 bool SDIO_IsReady() {
-  CORE_ASSERT(handle != NULL, "SDIO not initialized");
+  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
  return bool(handle->stcCardStatus.READY_FOR_DATA);
 }

 uint32_t SDIO_GetCardSize() {
-  CORE_ASSERT(handle != NULL, "SDIO not initialized");
+  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return 0);

  // Multiply number of blocks with block size to get size in bytes
  const uint64_t cardSizeBytes = uint64_t(handle->stcSdCardInfo.u32LogBlockNbr) * uint64_t(handle->stcSdCardInfo.u32LogBlockSize);
@@ -37,7 +37,10 @@ Timer::Timer() {
 }

 Timer::~Timer() {
-  timer_delete(timerid);
+  if (timerid != 0) {
+    timer_delete(timerid);
+    timerid = 0;
+  }
 }

 void Timer::init(uint32_t sig_id, uint32_t sim_freq, callback_fn* fn) {
@@ -21,6 +21,7 @@
 */

 #ifdef __PLAT_LINUX__
+#ifndef UNIT_TEST

 //#define GPIO_LOGGING // Full GPIO and Positional Logging

@@ -135,4 +136,5 @@ int main() {
  read_serial.join();
 }

+#endif // UNIT_TEST
 #endif // __PLAT_LINUX__
@@ -100,7 +100,7 @@ extern DefaultSerial1 USBSerial;
  #else
    #error "LCD_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
  #endif
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DWINOS_4)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.available()
  #endif
 #endif
@@ -112,7 +112,7 @@
  #else
    #error "LCD_SERIAL_PORT must be from 1 to 9, or -1 for Native USB."
  #endif
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)  || ENABLED(EXTENSIBLE_UI)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif
@@ -126,7 +126,7 @@
  void serialEvent2() __attribute__((weak));
 #endif
 #ifdef USING_HW_SERIAL3
-  HAL_HardwareSerial Serial3(USART3);
+  HAL_HardwareSerial HSerial3(USART3);
  void serialEvent3() __attribute__((weak));
 #endif
 #ifdef USING_HW_SERIAL4
@@ -147,11 +147,11 @@
 #endif
 #ifdef USING_HW_SERIAL6
  #ifdef USART6
-    HAL_HardwareSerial HSerial5(USART6);
+    HAL_HardwareSerial HSerial6(USART6);
  #else
-    HAL_HardwareSerial HSerial5(UART6);
+    HAL_HardwareSerial HSerial6(UART6);
  #endif
-  void serialEvent5() __attribute__((weak));
+  void serialEvent6() __attribute__((weak));
 #endif

 // Constructors ////////////////////////////////////////////////////////////////
@@ -43,6 +43,7 @@

 #else // Arduino non-DMA

+  FORCE_INLINE static uint8_t buffer_overruns() { return 0; }
  typedef void (*usart_rx_callback_t)(serial_t * obj);

  struct MarlinSerial : public HardwareSerial {
@@ -53,6 +54,8 @@
    inline void begin(unsigned long baud) { begin(baud, SERIAL_8N1); }

    void _rx_complete_irq(serial_t *obj);
+    FORCE_INLINE static uint8_t buffer_overruns() { return 0; } // Not implemented. Void to avoid platform-dependent code.
+    FORCE_INLINE uint32_t dropped() { return 0; }

    protected:
      usart_rx_callback_t _rx_callback;
@@ -58,8 +58,9 @@
 * Check for common serial pin conflicts
 */
 #define _CHECK_SERIAL_PIN(N) (( \
-    BTN_EN1 == N || DOGLCD_CS == N || HEATER_BED_PIN == N || FAN0_PIN == N || \
-    SDIO_D2_PIN == N || SDIO_D3_PIN == N || SDIO_CK_PIN == N || SDIO_CMD_PIN == N \
+    BTN_EN1 == N || BTN_EN2 == N ||DOGLCD_CS == N || HEATER_BED_PIN == N || FAN0_PIN == N || \
+    SDIO_D2_PIN == N || SDIO_D3_PIN == N || SDIO_CK_PIN == N || SDIO_CMD_PIN == N || \
+    Y_STEP_PIN == N || Y_ENABLE_PIN == N || E0_ENABLE_PIN == N || POWER_LOSS_PIN == N \
  ))
 #define CHECK_SERIAL_PIN(T,N) defined(UART##N##_##T##_PIN) && _CHECK_SERIAL_PIN(UART##N##_##T##_PIN)
 #if SERIAL_IN_USE(1)
@@ -37,50 +37,61 @@ LCD_CONTROLLER_TypeDef *TFT_FSMC::LCD;

 void TFT_FSMC::init() {
  uint32_t controllerAddress;
-  FSMC_NORSRAM_TimingTypeDef timing, extTiming;
+  FMC_OR_FSMC(NORSRAM_TimingTypeDef) timing, extTiming;

  uint32_t nsBank = (uint32_t)pinmap_peripheral(digitalPinToPinName(TFT_CS_PIN), pinMap_FSMC_CS);

  // Perform the SRAM1 memory initialization sequence
-  SRAMx.Instance = FSMC_NORSRAM_DEVICE;
-  SRAMx.Extended = FSMC_NORSRAM_EXTENDED_DEVICE;
+  SRAMx.Instance = FMC_OR_FSMC(NORSRAM_DEVICE);
+  SRAMx.Extended = FMC_OR_FSMC(NORSRAM_EXTENDED_DEVICE);
+
  // SRAMx.Init
  SRAMx.Init.NSBank = nsBank;
-  SRAMx.Init.DataAddressMux = FSMC_DATA_ADDRESS_MUX_DISABLE;
-  SRAMx.Init.MemoryType = FSMC_MEMORY_TYPE_SRAM;
-  SRAMx.Init.MemoryDataWidth = TERN(TFT_INTERFACE_FSMC_8BIT, FSMC_NORSRAM_MEM_BUS_WIDTH_8, FSMC_NORSRAM_MEM_BUS_WIDTH_16);
-  SRAMx.Init.BurstAccessMode = FSMC_BURST_ACCESS_MODE_DISABLE;
-  SRAMx.Init.WaitSignalPolarity = FSMC_WAIT_SIGNAL_POLARITY_LOW;
-  SRAMx.Init.WrapMode = FSMC_WRAP_MODE_DISABLE;
-  SRAMx.Init.WaitSignalActive = FSMC_WAIT_TIMING_BEFORE_WS;
-  SRAMx.Init.WriteOperation = FSMC_WRITE_OPERATION_ENABLE;
-  SRAMx.Init.WaitSignal = FSMC_WAIT_SIGNAL_DISABLE;
-  SRAMx.Init.ExtendedMode = FSMC_EXTENDED_MODE_ENABLE;
-  SRAMx.Init.AsynchronousWait = FSMC_ASYNCHRONOUS_WAIT_DISABLE;
-  SRAMx.Init.WriteBurst = FSMC_WRITE_BURST_DISABLE;
-  #ifdef STM32F4xx
-    SRAMx.Init.PageSize = FSMC_PAGE_SIZE_NONE;
+  SRAMx.Init.DataAddressMux     = FMC_OR_FSMC(DATA_ADDRESS_MUX_DISABLE);
+  SRAMx.Init.MemoryType         = FMC_OR_FSMC(MEMORY_TYPE_SRAM);
+  #ifdef STM32F446xx
+    SRAMx.Init.MemoryDataWidth  = TERN(TFT_INTERFACE_FMC_8BIT, FMC_NORSRAM_MEM_BUS_WIDTH_8, FMC_NORSRAM_MEM_BUS_WIDTH_16);
+  #else
+    SRAMx.Init.MemoryDataWidth  = TERN(TFT_INTERFACE_FSMC_8BIT, FSMC_NORSRAM_MEM_BUS_WIDTH_8, FSMC_NORSRAM_MEM_BUS_WIDTH_16);
  #endif
+  SRAMx.Init.BurstAccessMode    = FMC_OR_FSMC(BURST_ACCESS_MODE_DISABLE);
+  SRAMx.Init.WaitSignalPolarity = FMC_OR_FSMC(WAIT_SIGNAL_POLARITY_LOW);
+  SRAMx.Init.WrapMode           = FMC_OR_FSMC(WRAP_MODE_DISABLE);
+  SRAMx.Init.WaitSignalActive   = FMC_OR_FSMC(WAIT_TIMING_BEFORE_WS);
+  SRAMx.Init.WriteOperation     = FMC_OR_FSMC(WRITE_OPERATION_ENABLE);
+  SRAMx.Init.WaitSignal         = FMC_OR_FSMC(WAIT_SIGNAL_DISABLE);
+  SRAMx.Init.ExtendedMode       = FMC_OR_FSMC(EXTENDED_MODE_ENABLE);
+  SRAMx.Init.AsynchronousWait   = FMC_OR_FSMC(ASYNCHRONOUS_WAIT_DISABLE);
+  SRAMx.Init.WriteBurst         = FMC_OR_FSMC(WRITE_BURST_DISABLE);
+  #if defined(STM32F446xx) || defined(STM32F4xx)
+    SRAMx.Init.PageSize         = FMC_OR_FSMC(PAGE_SIZE_NONE);
+  #endif
+
  // Read Timing - relatively slow to ensure ID information is correctly read from TFT controller
-  // Can be decreases from 15-15-24 to 4-4-8 with risk of stability loss
-  timing.AddressSetupTime = 15;
-  timing.AddressHoldTime = 15;
-  timing.DataSetupTime = 24;
-  timing.BusTurnAroundDuration = 0;
-  timing.CLKDivision = 16;
-  timing.DataLatency = 17;
-  timing.AccessMode = FSMC_ACCESS_MODE_A;
+  // Can be decreased from 15-15-24 to 4-4-8 with risk of stability loss
+  timing.AddressSetupTime         = 15;
+  timing.AddressHoldTime          = 15;
+  timing.DataSetupTime            = 24;
+  timing.BusTurnAroundDuration    =  0;
+  timing.CLKDivision              = 16;
+  timing.DataLatency              = 17;
+  timing.AccessMode               = FMC_OR_FSMC(ACCESS_MODE_A);
+
  // Write Timing
  // Can be decreased from 8-15-8 to 0-0-1 with risk of stability loss
-  extTiming.AddressSetupTime = 8;
-  extTiming.AddressHoldTime = 15;
-  extTiming.DataSetupTime = 8;
-  extTiming.BusTurnAroundDuration = 0;
-  extTiming.CLKDivision = 16;
-  extTiming.DataLatency = 17;
-  extTiming.AccessMode = FSMC_ACCESS_MODE_A;
+  extTiming.AddressSetupTime      =  8;
+  extTiming.AddressHoldTime       = 15;
+  extTiming.DataSetupTime         =  8;
+  extTiming.BusTurnAroundDuration =  0;
+  extTiming.CLKDivision           = 16;
+  extTiming.DataLatency           = 17;
+  extTiming.AccessMode            = FMC_OR_FSMC(ACCESS_MODE_A);

-  __HAL_RCC_FSMC_CLK_ENABLE();
+  #ifdef STM32F446xx
+    __HAL_RCC_FMC_CLK_ENABLE();
+  #else
+    __HAL_RCC_FSMC_CLK_ENABLE();
+  #endif

  for (uint16_t i = 0; pinMap_FSMC[i].pin != NC; i++)
    pinmap_pinout(pinMap_FSMC[i].pin, pinMap_FSMC);
@@ -90,9 +101,9 @@ void TFT_FSMC::init() {
  controllerAddress = FSMC_BANK1_1;
  #ifdef PF0
    switch (nsBank) {
-      case FSMC_NORSRAM_BANK2: controllerAddress = FSMC_BANK1_2 ; break;
-      case FSMC_NORSRAM_BANK3: controllerAddress = FSMC_BANK1_3 ; break;
-      case FSMC_NORSRAM_BANK4: controllerAddress = FSMC_BANK1_4 ; break;
+      case FMC_OR_FSMC(NORSRAM_BANK2): controllerAddress = FSMC_BANK1_2; break;
+      case FMC_OR_FSMC(NORSRAM_BANK3): controllerAddress = FSMC_BANK1_3; break;
+      case FMC_OR_FSMC(NORSRAM_BANK4): controllerAddress = FSMC_BANK1_4; break;
    }
  #endif

@@ -100,49 +111,44 @@ void TFT_FSMC::init() {

  HAL_SRAM_Init(&SRAMx, &timing, &extTiming);

+  __HAL_RCC_DMA2_CLK_ENABLE();
+
  #ifdef STM32F1xx
-    __HAL_RCC_DMA1_CLK_ENABLE();
-    DMAtx.Instance = DMA1_Channel1;
+    DMAtx.Instance                = DMA2_Channel1;
  #elif defined(STM32F4xx)
-    __HAL_RCC_DMA2_CLK_ENABLE();
-    DMAtx.Instance = DMA2_Stream0;
-    DMAtx.Init.Channel = DMA_CHANNEL_0;
-    DMAtx.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
-    DMAtx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
-    DMAtx.Init.MemBurst = DMA_MBURST_SINGLE;
-    DMAtx.Init.PeriphBurst = DMA_PBURST_SINGLE;
+    DMAtx.Instance                = DMA2_Stream0;
+    DMAtx.Init.Channel            = DMA_CHANNEL_0;
+    DMAtx.Init.FIFOMode           = DMA_FIFOMODE_ENABLE;
+    DMAtx.Init.FIFOThreshold      = DMA_FIFO_THRESHOLD_FULL;
+    DMAtx.Init.MemBurst           = DMA_MBURST_SINGLE;
+    DMAtx.Init.PeriphBurst        = DMA_PBURST_SINGLE;
  #endif

-  DMAtx.Init.Direction = DMA_MEMORY_TO_MEMORY;
-  DMAtx.Init.MemInc = DMA_MINC_DISABLE;
-  DMAtx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
-  DMAtx.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
-  DMAtx.Init.Mode = DMA_NORMAL;
-  DMAtx.Init.Priority = DMA_PRIORITY_HIGH;
+  DMAtx.Init.Direction            = DMA_MEMORY_TO_MEMORY;
+  DMAtx.Init.MemInc               = DMA_MINC_DISABLE;
+  DMAtx.Init.PeriphDataAlignment  = DMA_PDATAALIGN_HALFWORD;
+  DMAtx.Init.MemDataAlignment     = DMA_MDATAALIGN_HALFWORD;
+  DMAtx.Init.Mode                 = DMA_NORMAL;
+  DMAtx.Init.Priority             = DMA_PRIORITY_HIGH;

  LCD = (LCD_CONTROLLER_TypeDef *)controllerAddress;
 }

 uint32_t TFT_FSMC::getID() {
-  uint32_t id;
  writeReg(0);
-  id = LCD->RAM;
-
-  if (id == 0)
-    id = readID(LCD_READ_ID);
-  if ((id & 0xFFFF) == 0 || (id & 0xFFFF) == 0xFFFF)
-    id = readID(LCD_READ_ID4);
+  uint32_t id = LCD->RAM;
+  if (id == 0) id = readID(LCD_READ_ID);
+  if ((id & 0xFFFF) == 0 || (id & 0xFFFF) == 0xFFFF) id = readID(LCD_READ_ID4);
  return id;
 }

-uint32_t TFT_FSMC::readID(const tft_data_t inReg) {
-  uint32_t id;
+uint32_t TFT_FSMC::readID(tft_data_t inReg) {
  writeReg(inReg);
-  id = LCD->RAM; // dummy read
+  uint32_t id = LCD->RAM; // dummy read
  id = inReg << 24;
  id |= (LCD->RAM & 0x00FF) << 16;
  id |= (LCD->RAM & 0x00FF) << 8;
-  id |= LCD->RAM & 0x00FF;
+  id |= (LCD->RAM & 0x00FF);
  return id;
 }

@@ -155,7 +161,9 @@ bool TFT_FSMC::isBusy() {
    #define __IS_DMA_CONFIGURED(__HANDLE__)   ((__HANDLE__)->Instance->PAR != 0)
  #endif

-  if (!__IS_DMA_CONFIGURED(&DMAtx)) return false;
+  #ifdef __IS_DMA_CONFIGURED
+    if (!__IS_DMA_CONFIGURED(&DMAtx)) return false;
+  #endif

  // Check if DMA transfer error or transfer complete flags are set
  if ((__HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TE_FLAG_INDEX(&DMAtx)) == 0) && (__HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TC_FLAG_INDEX(&DMAtx)) == 0)) return true;
@@ -174,8 +182,6 @@ void TFT_FSMC::transmitDMA(uint32_t memoryIncrease, uint16_t *data, uint16_t cou
  DMAtx.Init.PeriphInc = memoryIncrease;
  HAL_DMA_Init(&DMAtx);
  HAL_DMA_Start(&DMAtx, (uint32_t)data, (uint32_t)&(LCD->RAM), count);
-
-  TERN_(TFT_SHARED_IO, while (isBusy()));
 }

 void TFT_FSMC::transmit(uint32_t memoryIncrease, uint16_t *data, uint16_t count) {
@@ -28,11 +28,7 @@
 #elif defined(STM32F4xx)
  #include "stm32f4xx_hal.h"
 #else
-  #error "FSMC TFT is currently only supported on STM32F1 and STM32F4 hardware."
-#endif
-
-#ifndef HAL_SRAM_MODULE_ENABLED
-  #error "SRAM module disabled for the STM32 framework (HAL_SRAM_MODULE_ENABLED)! Please consult the development team."
+  #error "FSMC/FMC TFT is currently only supported on STM32F1 and STM32F4 hardware."
 #endif

 #ifndef LCD_READ_ID
@@ -55,6 +51,12 @@ typedef struct {
  __IO tft_data_t RAM;
 } LCD_CONTROLLER_TypeDef;

+#ifdef STM32F446xx
+  #define FMC_OR_FSMC(N) _CAT(FMC_, N)
+#else
+  #define FMC_OR_FSMC(N) _CAT(FSMC_, N)
+#endif
+
 class TFT_FSMC {
  private:
    static SRAM_HandleTypeDef SRAMx;
@@ -62,7 +64,7 @@ class TFT_FSMC {

    static LCD_CONTROLLER_TypeDef *LCD;

-    static uint32_t readID(const tft_data_t reg);
+    static uint32_t readID(tft_data_t inReg);
    static void transmit(tft_data_t data) { LCD->RAM = data; __DSB(); }
    static void transmit(uint32_t memoryIncrease, uint16_t *data, uint16_t count);
    static void transmitDMA(uint32_t memoryIncrease, uint16_t *data, uint16_t count);
@@ -94,7 +96,11 @@ class TFT_FSMC {
 #ifdef STM32F1xx
  #define FSMC_PIN_DATA   STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, AFIO_NONE)
 #elif defined(STM32F4xx)
-  #define FSMC_PIN_DATA   STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF12_FSMC)
+  #ifdef STM32F446xx
+    #define FSMC_PIN_DATA   STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF12_FMC)
+  #else
+    #define FSMC_PIN_DATA   STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF12_FSMC)
+  #endif
  #define FSMC_BANK1_1    0x60000000U
  #define FSMC_BANK1_2    0x64000000U
  #define FSMC_BANK1_3    0x68000000U
@@ -104,35 +110,35 @@ class TFT_FSMC {
 #endif

 const PinMap pinMap_FSMC[] = {
-  {PD_14,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D00
-  {PD_15,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D01
-  {PD_0,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D02
-  {PD_1,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D03
-  {PE_7,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D04
-  {PE_8,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D05
-  {PE_9,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D06
-  {PE_10,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D07
+  {PD_14,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D00
+  {PD_15,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D01
+  {PD_0,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D02
+  {PD_1,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D03
+  {PE_7,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D04
+  {PE_8,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D05
+  {PE_9,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D06
+  {PE_10,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D07
  #if DISABLED(TFT_INTERFACE_FSMC_8BIT)
-    {PE_11,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D08
-    {PE_12,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D09
-    {PE_13,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D10
-    {PE_14,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D11
-    {PE_15,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D12
-    {PD_8,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D13
-    {PD_9,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D14
-    {PD_10,  FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_D15
+    {PE_11,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D08
+    {PE_12,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D09
+    {PE_13,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D10
+    {PE_14,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D11
+    {PE_15,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D12
+    {PD_8,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D13
+    {PD_9,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D14
+    {PD_10,  FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_D15
  #endif
-  {PD_4,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_NOE
-  {PD_5,   FSMC_NORSRAM_DEVICE, FSMC_PIN_DATA}, // FSMC_NWE
+  {PD_4,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_NOE
+  {PD_5,   FMC_OR_FSMC(NORSRAM_DEVICE), FSMC_PIN_DATA}, // FSMC_NWE
  {NC,    NP,    0}
 };

 const PinMap pinMap_FSMC_CS[] = {
-  {PD_7,  (void *)FSMC_NORSRAM_BANK1, FSMC_PIN_DATA}, // FSMC_NE1
+  {PD_7,  (void *)FMC_OR_FSMC(NORSRAM_BANK1), FSMC_PIN_DATA}, // FSMC_NE1
  #ifdef PF0
-    {PG_9,  (void *)FSMC_NORSRAM_BANK2, FSMC_PIN_DATA}, // FSMC_NE2
-    {PG_10, (void *)FSMC_NORSRAM_BANK3, FSMC_PIN_DATA}, // FSMC_NE3
-    {PG_12, (void *)FSMC_NORSRAM_BANK4, FSMC_PIN_DATA}, // FSMC_NE4
+    {PG_9,  (void *)FMC_OR_FSMC(NORSRAM_BANK2), FSMC_PIN_DATA}, // FSMC_NE2
+    {PG_10, (void *)FMC_OR_FSMC(NORSRAM_BANK3), FSMC_PIN_DATA}, // FSMC_NE3
+    {PG_12, (void *)FMC_OR_FSMC(NORSRAM_BANK4), FSMC_PIN_DATA}, // FSMC_NE4
  #endif
  {NC,    NP,    0}
 };
@@ -138,7 +138,7 @@
    #define LCD_SERIAL MSERIAL(1) // dummy port
    static_assert(false, "LCD_SERIAL_PORT must be from 1 to " STRINGIFY(NUM_UARTS) ". You can also use -1 if the board supports Native USB.")
  #endif
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(DWINOS_4)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif
@@ -77,8 +77,6 @@
  #include "lcd/e3v2/common/encoder.h"
  #if ENABLED(DWIN_CREALITY_LCD)
    #include "lcd/e3v2/creality/dwin.h"
-  #elif ENABLED(DWIN_LCD_PROUI)
-    #include "lcd/e3v2/proui/dwin.h"
  #elif ENABLED(DWIN_CREALITY_LCD_JYERSUI)
    #include "lcd/e3v2/jyersui/dwin.h"
  #endif
@@ -476,11 +474,16 @@ inline void manage_inactivity(const bool no_stepper_sleep=false) {

  #if HAS_KILL

-    // Check if the kill button was pressed and wait just in case it was an accidental
-    // key kill key press
+    // Check if the kill button was pressed and wait to ensure the signal is not noise
+    // typically caused by poor insulation and grounding on LCD cables.
+    // Lower numbers here will increase response time and therefore safety rating.
+    // It is recommended to set this as low as possibe without false triggers.
    // -------------------------------------------------------------------------------
+    #ifndef KILL_DELAY
+      #define KILL_DELAY 250
+    #endif
+
    static int killCount = 0;   // make the inactivity button a bit less responsive
-    const int KILL_DELAY = 750;
    if (kill_state())
      killCount++;
    else if (killCount > 0)
@@ -671,6 +674,12 @@ inline void manage_inactivity(const bool no_stepper_sleep=false) {

  TERN_(HOTEND_IDLE_TIMEOUT, hotend_idle.check());

+  #if ANY(PSU_CONTROL, AUTO_POWER_CONTROL) && PIN_EXISTS(PS_ON_EDM)
+    if ( ELAPSED(ms, powerManager.last_state_change_ms + PS_EDM_RESPONSE)
+      && (READ(PS_ON_PIN) != READ(PS_ON_EDM_PIN) || TERN0(PSU_OFF_REDUNDANT, extDigitalRead(PS_ON1_PIN) != extDigitalRead(PS_ON1_EDM_PIN)))
+    ) kill(GET_TEXT_F(MSG_POWER_EDM_FAULT));
+  #endif
+
  #if ENABLED(EXTRUDER_RUNOUT_PREVENT)
    if (thermalManager.degHotend(active_extruder) > (EXTRUDER_RUNOUT_MINTEMP)
      && ELAPSED(ms, gcode.previous_move_ms + SEC_TO_MS(EXTRUDER_RUNOUT_SECONDS))
@@ -1588,11 +1597,11 @@ void setup() {
    SERIAL_ECHO_TERNARY(err, "BL24CXX Check ", "failed", "succeeded", "!\n");
  #endif

-  #if HAS_DWIN_E3V2_BASIC
+  #if ENABLED(DWIN_CREALITY_LCD)
    SETUP_RUN(dwinInitScreen());
  #endif

-  #if HAS_SERVICE_INTERVALS && !HAS_DWIN_E3V2_BASIC
+  #if HAS_SERVICE_INTERVALS && DISABLED(DWIN_CREALITY_LCD)
    SETUP_RUN(ui.reset_status(true));  // Show service messages or keep current status
  #endif

@@ -131,6 +131,7 @@
 #define BOARD_PXMALION_CORE_I3        1164  // Pxmalion Core I3
 #define BOARD_PANOWIN_CUTLASS         1165  // Panowin Cutlass (as found in the Panowin F1)
 #define BOARD_KODAMA_BARDO            1166  // Kodama Bardo V1.x (as found in the Kodama Trinus)
+#define BOARD_DAGOMA_D6               1167  // Dagoma D6 (as found in the Dagoma DiscoUltimate V2 TMC)

 //
 // RAMBo and derivatives
@@ -459,7 +460,7 @@
 #define BOARD_OPULO_LUMEN_REV4        5242  // Opulo Lumen PnP Controller REV4 (STM32F407VE / STM32F407VG)
 #define BOARD_FYSETC_SPIDER_KING407   5243  // FYSETC Spider King407 (STM32F407ZG)
 #define BOARD_MKS_SKIPR_V1            5244  // MKS SKIPR v1.0 all-in-one board (STM32F407VE)
-#define BOARD_TRONXY_V10              5245  // TRONXY V10 (STM32F446ZE)
+#define BOARD_TRONXY_CXY_446_V10      5245  // TRONXY CXY-446-V10-220413/CXY-V6-191121 (STM32F446ZE)
 #define BOARD_CREALITY_F401RE         5246  // Creality CR4NS200141C13 (STM32F401RE) as found in the Ender-5 S1
 #define BOARD_BLACKPILL_CUSTOM        5247  // Custom board based on STM32F401CDU6.
 #define BOARD_I3DBEEZ9_V1             5248  // I3DBEEZ9 V1 (STM32F407ZG)
@@ -41,8 +41,6 @@
 #define _TMC2208_STANDALONE 0x2208B
 #define _TMC2209            0x2209A
 #define _TMC2209_STANDALONE 0x2209B
-#define _TMC26X             0x2600A
-#define _TMC26X_STANDALONE  0x2600B
 #define _TMC2660            0x2660A
 #define _TMC2660_STANDALONE 0x2660B
 #define _TMC5130            0x5130A
@@ -107,8 +105,8 @@

 #if (    HAS_DRIVER(TMC2130_STANDALONE) || HAS_DRIVER(TMC2160_STANDALONE) \
      || HAS_DRIVER(TMC2208_STANDALONE) || HAS_DRIVER(TMC2209_STANDALONE) \
-      || HAS_DRIVER(TMC26X_STANDALONE)  || HAS_DRIVER(TMC2660_STANDALONE) \
-      || HAS_DRIVER(TMC5130_STANDALONE) || HAS_DRIVER(TMC5160_STANDALONE) )
+      || HAS_DRIVER(TMC2660_STANDALONE) || HAS_DRIVER(TMC5130_STANDALONE) \
+      || HAS_DRIVER(TMC5160_STANDALONE) )
  #define HAS_TRINAMIC_STANDALONE 1
 #endif

@@ -125,13 +123,13 @@
                           || AXIS_DRIVER_TYPE(A,TMC2660) \
                           || AXIS_DRIVER_TYPE(A,TMC5130) || AXIS_DRIVER_TYPE(A,TMC5160) )

-#define AXIS_IS_TMC_CONFIG(A)   ( AXIS_IS_TMC(A) || AXIS_DRIVER_TYPE(A,TMC26X) )
+#define AXIS_IS_TMC_CONFIG AXIS_IS_TMC

 // Test for a driver that uses SPI - this allows checking whether a _CS_ pin
 // is considered sensitive
 #define AXIS_HAS_SPI(A)  (    AXIS_DRIVER_TYPE(A,TMC2130) || AXIS_DRIVER_TYPE(A,TMC2160) \
-                           || AXIS_DRIVER_TYPE(A,TMC26X)  || AXIS_DRIVER_TYPE(A,TMC2660) \
-                           || AXIS_DRIVER_TYPE(A,TMC5130) || AXIS_DRIVER_TYPE(A,TMC5160) )
+                           || AXIS_DRIVER_TYPE(A,TMC2660) || AXIS_DRIVER_TYPE(A,TMC5130) \
+                           || AXIS_DRIVER_TYPE(A,TMC5160) )

 #define AXIS_HAS_UART(A) ( AXIS_DRIVER_TYPE(A,TMC2208) || AXIS_DRIVER_TYPE(A,TMC2209) )

@@ -184,10 +182,8 @@
 #if ANY_AXIS_HAS(SPI)
  #define HAS_TMC_SPI 1
 #endif
-
-//
-// TMC26XX Stepper Drivers
-//
-#if HAS_DRIVER(TMC26X)
-  #define HAS_TMC26X 1
+#if HAS_STALLGUARD || HAS_DRIVER(TMC2160_STANDALONE) || HAS_DRIVER(TMC2130_STANDALONE) \
+                   || HAS_DRIVER(TMC2209_STANDALONE) || HAS_DRIVER(TMC2660_STANDALONE) \
+                   || HAS_DRIVER(TMC5130_STANDALONE) || HAS_DRIVER(TMC5160_STANDALONE)
+  #define HAS_DIAG_PINS 1
 #endif
@@ -449,7 +449,7 @@ struct XYval {
  // Length reduced to one dimension
  FI constexpr T magnitude()    const { return (T)sqrtf(x*x + y*y); }
  // Pointer to the data as a simple array
-  FI operator T* ()                   { return pos; }
+  explicit FI operator T* ()          { return pos; }
  // If any element is true then it's true
  FI constexpr operator bool()  const { return x || y; }
  // Smallest element
@@ -599,7 +599,7 @@ struct XYZval {
  // Length reduced to one dimension
  FI constexpr T magnitude()    const { return (T)TERN(HAS_X_AXIS, sqrtf(NUM_AXIS_GANG(x*x, + y*y, + z*z, + i*i, + j*j, + k*k, + u*u, + v*v, + w*w)), 0); }
  // Pointer to the data as a simple array
-  FI operator T* ()                   { return pos; }
+  explicit FI operator T* ()          { return pos; }
  // If any element is true then it's true
  FI constexpr operator bool()  const { return 0 NUM_AXIS_GANG(|| x, || y, || z, || i, || j, || k, || u, || v, || w); }
  // Smallest element
@@ -747,7 +747,7 @@ struct XYZEval {
  // Length reduced to one dimension
  FI constexpr T magnitude()    const { return (T)sqrtf(LOGICAL_AXIS_GANG(+ e*e, + x*x, + y*y, + z*z, + i*i, + j*j, + k*k, + u*u, + v*v, + w*w)); }
  // Pointer to the data as a simple array
-  FI operator T* ()                   { return pos; }
+  explicit FI operator T* ()          { return pos; }
  // If any element is true then it's true
  FI constexpr operator bool()  const { return 0 LOGICAL_AXIS_GANG(|| e, || x, || y, || z, || i, || j, || k, || u, || v, || w); }
  // Smallest element
@@ -63,7 +63,7 @@
     */
    void mesh_bed_leveling::line_to_destination(const_feedRate_t scaled_fr_mm_s, uint8_t x_splits, uint8_t y_splits) {
      // Get current and destination cells for this line
-      xy_int8_t scel = cell_indexes(current_position), ecel = cell_indexes(destination);
+      xy_uint8_t scel = cell_indexes(current_position), ecel = cell_indexes(destination);
      NOMORE(scel.x, GRID_MAX_CELLS_X - 1);
      NOMORE(scel.y, GRID_MAX_CELLS_Y - 1);
      NOMORE(ecel.x, GRID_MAX_CELLS_X - 1);
@@ -80,7 +80,7 @@

      float normalized_dist;
      xyze_pos_t dest;
-      const int8_t gcx = _MAX(scel.x, ecel.x), gcy = _MAX(scel.y, ecel.y);
+      const uint8_t gcx = _MAX(scel.x, ecel.x), gcy = _MAX(scel.y, ecel.y);

      // Crosses on the X and not already split on this X?
      // The x_splits flags are insurance against rounding errors.
@@ -95,7 +95,7 @@ public:
  static void report_current_mesh();
  static void report_state();
  static void save_ubl_active_state_and_disable();
-  static void restore_ubl_active_state_and_leave();
+  static void restore_ubl_active_state(const bool is_done=true);
  static void display_map(const uint8_t) __O0;
  static mesh_index_pair find_closest_mesh_point_of_type(const MeshPointType, const xy_pos_t&, const bool=false, MeshFlags *done_flags=nullptr) __O0;
  static mesh_index_pair find_furthest_invalid_mesh_point() __O0;
@@ -309,7 +309,7 @@ void unified_bed_leveling::G29() {
    #if ALL(DWIN_LCD_PROUI, ZHOME_BEFORE_LEVELING)
      save_ubl_active_state_and_disable();
      gcode.process_subcommands_now(F("G28Z"));
-      restore_ubl_active_state_and_leave();
+      restore_ubl_active_state(false); // ...without telling ExtUI "done"
    #else
      // Send 'N' to force homing before G29 (internal only)
      if (axes_should_home() || parser.seen_test('N')) gcode.home_all_axes();
@@ -425,7 +425,7 @@ void unified_bed_leveling::G29() {
    if (parser.seen_test('J')) {
      save_ubl_active_state_and_disable();
      tilt_mesh_based_on_probed_grid(param.J_grid_size == 0); // Zero size does 3-Point
-      restore_ubl_active_state_and_leave();
+      restore_ubl_active_state();
      #if ENABLED(UBL_G29_J_RECENTER)
        do_blocking_move_to_xy(0.5f * ((MESH_MIN_X) + (MESH_MAX_X)), 0.5f * ((MESH_MIN_Y) + (MESH_MAX_Y)));
      #endif
@@ -754,7 +754,6 @@ void unified_bed_leveling::shift_mesh_height() {

    TERN_(HAS_MARLINUI_MENU, ui.capture());
    TERN_(EXTENSIBLE_UI, ExtUI::onLevelingStart());
-    TERN_(DWIN_LCD_PROUI, dwinLevelingStart());

    save_ubl_active_state_and_disable();  // No bed level correction so only raw data is obtained
    grid_count_t count = GRID_MAX_POINTS;
@@ -768,7 +767,6 @@ void unified_bed_leveling::shift_mesh_height() {
      SERIAL_ECHOLNPGM("Probing mesh point ", point_num, "/", GRID_MAX_POINTS, ".");
      TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), point_num, int(GRID_MAX_POINTS)));
      TERN_(HAS_BACKLIGHT_TIMEOUT, ui.refresh_backlight_timeout());
-      TERN_(DWIN_LCD_PROUI, dwinRedrawScreen());

      #if HAS_MARLINUI_MENU
        if (ui.button_pressed()) {
@@ -778,8 +776,7 @@ void unified_bed_leveling::shift_mesh_height() {
          ui.quick_feedback();
          ui.release();
          probe.stow(); // Release UI before stow to allow for PAUSE_BEFORE_DEPLOY_STOW
-          TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
-          return restore_ubl_active_state_and_leave();
+          return restore_ubl_active_state();
        }
      #endif

@@ -815,15 +812,12 @@ void unified_bed_leveling::shift_mesh_height() {

    probe.move_z_after_probing();

-    restore_ubl_active_state_and_leave();
-
    do_blocking_move_to_xy(
      constrain(nearby.x - probe.offset_xy.x, MESH_MIN_X, MESH_MAX_X),
      constrain(nearby.y - probe.offset_xy.y, MESH_MIN_Y, MESH_MAX_Y)
    );

-    TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
-    TERN_(DWIN_LCD_PROUI, dwinLevelingDone());
+    restore_ubl_active_state();
  }

 #endif // HAS_BED_PROBE
@@ -932,7 +926,7 @@ void set_message_with_feedback(FSTR_P const fstr) {
    if (param.V_verbosity > 1)
      SERIAL_ECHOLNPGM("Business Card is ", p_float_t(thickness, 4), "mm thick.");

-    restore_ubl_active_state_and_leave();
+    restore_ubl_active_state();

    return thickness;
  }
@@ -987,7 +981,7 @@ void set_message_with_feedback(FSTR_P const fstr) {
      if (_click_and_hold([]{
        SERIAL_ECHOLNPGM("\nMesh only partially populated.");
        do_z_clearance(Z_CLEARANCE_DEPLOY_PROBE);
-      })) return restore_ubl_active_state_and_leave();
+      })) return restore_ubl_active_state();

      // Store the Z position minus the shim height
      z_values[lpos.x][lpos.y] = current_position.z - thick;
@@ -1002,10 +996,8 @@ void set_message_with_feedback(FSTR_P const fstr) {

    if (do_ubl_mesh_map) display_map(param.T_map_type);  // show user where we're probing

-    restore_ubl_active_state_and_leave();
+    restore_ubl_active_state();
    do_blocking_move_to_xy_z(pos, Z_CLEARANCE_DEPLOY_PROBE);
-
-    TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
  }

  /**
@@ -1111,7 +1103,7 @@ void set_message_with_feedback(FSTR_P const fstr) {
    } while (lpos.x >= 0 && --param.R_repetition > 0);

    if (do_ubl_mesh_map) display_map(param.T_map_type);
-    restore_ubl_active_state_and_leave();
+    restore_ubl_active_state();

    do_blocking_move_to_xy_z(pos, Z_TWEEN_SAFE_CLEARANCE);

@@ -1263,17 +1255,20 @@ void unified_bed_leveling::save_ubl_active_state_and_disable() {
  set_bed_leveling_enabled(false);
 }

-void unified_bed_leveling::restore_ubl_active_state_and_leave() {
+void unified_bed_leveling::restore_ubl_active_state(const bool is_done/*=true*/) {
  TERN_(HAS_MARLINUI_MENU, ui.release());
  #if ENABLED(UBL_DEVEL_DEBUGGING)
    if (--ubl_state_recursion_chk) {
-      SERIAL_ECHOLNPGM("restore_ubl_active_state_and_leave() called too many times.");
+      SERIAL_ECHOLNPGM("restore_ubl_active_state() called too many times.");
      set_message_with_feedback(GET_TEXT_F(MSG_UBL_RESTORE_ERROR));
      return;
    }
  #endif
  set_bed_leveling_enabled(ubl_state_at_invocation);
-  TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
+
+  if (is_done) {
+    TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
+  }
 }

 mesh_index_pair unified_bed_leveling::find_furthest_invalid_mesh_point() {
@@ -212,6 +212,8 @@ void FWRetract::M207() {
 }

 void FWRetract::M207_report() {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  SERIAL_ECHOLNPGM_P(
      PSTR("  M207 S"), LINEAR_UNIT(settings.retract_length)
    , PSTR(" W"), LINEAR_UNIT(settings.swap_retract_length)
@@ -237,6 +239,8 @@ void FWRetract::M208() {
 }

 void FWRetract::M208_report() {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  SERIAL_ECHOLNPGM(
      "  M208 S", LINEAR_UNIT(settings.retract_recover_extra)
    , " W", LINEAR_UNIT(settings.swap_retract_recover_extra)
@@ -258,6 +262,8 @@ void FWRetract::M208_report() {
  }

  void FWRetract::M209_report() {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    SERIAL_ECHOLNPGM("  M209 S", AS_DIGIT(autoretract_enabled));
  }

@@ -186,18 +186,18 @@ void HostUI::action(FSTR_P const fstr, const bool eol) {
        switch (response) {

          case 0: // "Purge More" button
-            #if ALL(M600_PURGE_MORE_RESUMABLE, ADVANCED_PAUSE_FEATURE)
+            #if ENABLED(M600_PURGE_MORE_RESUMABLE)
              pause_menu_response = PAUSE_RESPONSE_EXTRUDE_MORE;  // Simulate menu selection (menu exits, doesn't extrude more)
            #endif
            break;

          case 1: // "Continue" / "Disable Runout" button
-            #if ALL(M600_PURGE_MORE_RESUMABLE, ADVANCED_PAUSE_FEATURE)
+            #if ENABLED(M600_PURGE_MORE_RESUMABLE)
              pause_menu_response = PAUSE_RESPONSE_RESUME_PRINT;  // Simulate menu selection
            #endif
            #if HAS_FILAMENT_SENSOR
              if (runout.filament_ran_out) {                      // Disable a triggered sensor
-                runout.enabled = false;
+                runout.enabled[active_extruder] = false;
                runout.reset();
              }
            #endif
@@ -32,7 +32,9 @@ typedef struct {
    timeout       = HOTEND_IDLE_TIMEOUT_SEC;
    trigger       = HOTEND_IDLE_MIN_TRIGGER;
    nozzle_target = HOTEND_IDLE_NOZZLE_TARGET;
-    bed_target    = HOTEND_IDLE_BED_TARGET;
+    #if HAS_HEATED_BED
+      bed_target  = HOTEND_IDLE_BED_TARGET;
+    #endif
  }
 } hotend_idle_settings_t;

@@ -56,7 +56,7 @@ public:

  #if HAS_TEMP_HOTEND || HAS_HEATED_BED || HAS_HEATED_CHAMBER
    static void onHeatingDone()             { leds.set_white(); }
-    static void onPidTuningDone(LEDColor c) { leds.set_color(c); }
+    static void onPIDTuningDone(LEDColor c) { leds.set_color(c); }
  #endif

  #if HAS_MEDIA
@@ -72,6 +72,26 @@
  uint16_t CodeProfiler::call_count = 0;
 #endif

+#if defined(MAX7219_DEBUG_PLANNER_HEAD) && defined(MAX7219_DEBUG_PLANNER_TAIL) && MAX7219_DEBUG_PLANNER_HEAD == MAX7219_DEBUG_PLANNER_TAIL
+  static int16_t last_head_cnt = 0xF, last_tail_cnt = 0xF;
+#else
+  #ifdef MAX7219_DEBUG_PLANNER_HEAD
+    static int16_t last_head_cnt = 0x1;
+  #endif
+  #ifdef MAX7219_DEBUG_PLANNER_TAIL
+    static int16_t last_tail_cnt = 0x1;
+  #endif
+#endif
+#ifdef MAX7219_DEBUG_PLANNER_QUEUE
+  static int16_t last_depth = 0;
+#endif
+#ifdef MAX7219_DEBUG_PROFILE
+  static uint8_t last_time_fraction = 0;
+#endif
+#ifdef MAX7219_DEBUG_MULTISTEPPING
+  static uint8_t last_multistepping = 0;
+#endif
+
 Max7219 max7219;

 uint8_t Max7219::led_line[MAX7219_LINES]; // = { 0 };
@@ -550,6 +570,29 @@ void Max7219::init() {
  #if MAX7219_INIT_TEST
    start_test_pattern();
  #endif
+
+  #ifdef MAX7219_REINIT_ON_POWERUP
+    #if defined(MAX7219_DEBUG_PLANNER_HEAD) && defined(MAX7219_DEBUG_PLANNER_TAIL) && MAX7219_DEBUG_PLANNER_HEAD == MAX7219_DEBUG_PLANNER_TAIL
+      last_head_cnt = 0xF;
+      last_tail_cnt = 0xF;
+    #else
+      #ifdef MAX7219_DEBUG_PLANNER_HEAD
+        last_head_cnt = 0x1;
+      #endif
+      #ifdef MAX7219_DEBUG_PLANNER_TAIL
+        last_tail_cnt = 0x1;
+      #endif
+    #endif
+    #ifdef MAX7219_DEBUG_PLANNER_QUEUE
+      last_depth = 0;
+    #endif
+    #ifdef MAX7219_DEBUG_PROFILE
+      last_time_fraction = 0;
+    #endif
+    #ifdef MAX7219_DEBUG_MULTISTEPPING
+      last_multistepping = 0;
+    #endif
+  #endif
 }

 /**
@@ -676,8 +719,6 @@ void Max7219::idle_tasks() {

  #if defined(MAX7219_DEBUG_PLANNER_HEAD) && defined(MAX7219_DEBUG_PLANNER_TAIL) && MAX7219_DEBUG_PLANNER_HEAD == MAX7219_DEBUG_PLANNER_TAIL

-    static int16_t last_head_cnt = 0xF, last_tail_cnt = 0xF;
-
    if (last_head_cnt != head || last_tail_cnt != tail) {
      range16(MAX7219_DEBUG_PLANNER_HEAD, last_tail_cnt, tail, last_head_cnt, head, &row_change_mask);
      last_head_cnt = head;
@@ -687,7 +728,6 @@ void Max7219::idle_tasks() {
  #else

    #ifdef MAX7219_DEBUG_PLANNER_HEAD
-      static int16_t last_head_cnt = 0x1;
      if (last_head_cnt != head) {
        mark16(MAX7219_DEBUG_PLANNER_HEAD, last_head_cnt, head, &row_change_mask);
        last_head_cnt = head;
@@ -695,7 +735,6 @@ void Max7219::idle_tasks() {
    #endif

    #ifdef MAX7219_DEBUG_PLANNER_TAIL
-      static int16_t last_tail_cnt = 0x1;
      if (last_tail_cnt != tail) {
        mark16(MAX7219_DEBUG_PLANNER_TAIL, last_tail_cnt, tail, &row_change_mask);
        last_tail_cnt = tail;
@@ -714,7 +753,6 @@ void Max7219::idle_tasks() {
  #endif

  #ifdef MAX7219_DEBUG_PROFILE
-    static uint8_t last_time_fraction = 0;
    const uint8_t current_time_fraction = (uint16_t(CodeProfiler::get_time_fraction()) * MAX7219_NUMBER_UNITS + 8) / 16;
    if (current_time_fraction != last_time_fraction) {
      quantity(MAX7219_DEBUG_PROFILE, last_time_fraction, current_time_fraction, &row_change_mask);
@@ -135,7 +135,7 @@ void MMU2::reset() {
 int8_t MMU2::get_current_tool() { return extruder == MMU2_NO_TOOL ? -1 : extruder; }

 #if ANY(HAS_PRUSA_MMU2S, MMU_EXTRUDER_SENSOR)
-  #define FILAMENT_PRESENT() (READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE)
+  #define FILAMENT_PRESENT() (READ(FIL_RUNOUT1_PIN) != runout.out_state())
 #else
  #define FILAMENT_PRESENT() true
 #endif
@@ -23,6 +23,8 @@
 /**
 * feature/pause.cpp - Pause feature support functions
 * This may be combined with related G-codes if features are consolidated.
+ *
+ * Note: Calls to ui.pause_show_message are passed to either ExtUI or MarlinUI.
 */

 #include "../inc/MarlinConfigPre.h"
@@ -60,8 +62,6 @@

 #if ENABLED(EXTENSIBLE_UI)
  #include "../lcd/extui/ui_api.h"
-#elif ENABLED(DWIN_LCD_PROUI)
-  #include "../lcd/e3v2/proui/dwin.h"
 #endif

 #include "../lcd/marlinui.h"
@@ -148,7 +148,7 @@ static bool ensure_safe_temperature(const bool wait=true, const PauseMode mode=P
      thermalManager.setTargetHotend(thermalManager.extrude_min_temp, active_extruder);
  #endif

-  ui.pause_show_message(PAUSE_MESSAGE_HEATING, mode); UNUSED(mode);
+  ui.pause_show_message(PAUSE_MESSAGE_HEATING, mode);

  if (wait) return thermalManager.wait_for_hotend(active_extruder);

@@ -214,12 +214,21 @@ bool load_filament(const_float_t slow_load_length/*=0*/, const_float_t fast_load
      impatient_beep(max_beep_count);
      #if ALL(FILAMENT_CHANGE_RESUME_ON_INSERT, FILAMENT_RUNOUT_SENSOR)
        #if MULTI_FILAMENT_SENSOR
-          #define _CASE_INSERTED(N) case N-1: if (READ(FIL_RUNOUT##N##_PIN) != FIL_RUNOUT##N##_STATE) wait_for_user = false; break;
-          switch (active_extruder) {
-            REPEAT_1(NUM_RUNOUT_SENSORS, _CASE_INSERTED)
+          LOOP_S_LE_N(i, 1, NUM_RUNOUT_SENSORS) {
+            pin_t pin;
+            switch (i) {
+              default: continue;
+              #define _CASE_RUNOUT(N) case N: pin = FIL_RUNOUT##N##_PIN; break;
+              REPEAT_1(NUM_RUNOUT_SENSORS, _CASE_RUNOUT)
+              #undef _CASE_RUNOUT
+            }
+            const RunoutMode rm = runout.mode[i - 1];
+            if (rm != RM_NONE && rm != RM_MOTION_SENSOR && extDigitalRead(pin) != runout.out_state(i - 1))
+              wait_for_user = false;
          }
        #else
-          if (READ(FIL_RUNOUT_PIN) != FIL_RUNOUT_STATE) wait_for_user = false;
+          if (READ(FIL_RUNOUT_PIN) != runout.out_state(active_extruder))
+            wait_for_user = false;
        #endif
      #endif
      idle_no_sleep();
@@ -288,8 +297,8 @@ bool load_filament(const_float_t slow_load_length/*=0*/, const_float_t fast_load
          // Show "Purge More" / "Resume" menu and wait for reply
          KEEPALIVE_STATE(PAUSED_FOR_USER);
          wait_for_user = false;
-          #if ANY(HAS_MARLINUI_MENU, DWIN_LCD_PROUI)
-            ui.pause_show_message(PAUSE_MESSAGE_OPTION); // Also sets PAUSE_RESPONSE_WAIT_FOR
+          #if ANY(HAS_MARLINUI_MENU, EXTENSIBLE_UI)
+            ui.pause_show_message(PAUSE_MESSAGE_OPTION); // MarlinUI and MKS UI also set PAUSE_RESPONSE_WAIT_FOR
          #else
            pause_menu_response = PAUSE_RESPONSE_WAIT_FOR;
          #endif
@@ -680,7 +689,7 @@ void resume_print(const_float_t slow_load_length/*=0*/, const_float_t fast_load_
  #endif

  // If resume_position is negative
-  if (resume_position.e < 0) unscaled_e_move(resume_position.e, feedRate_t(PAUSE_PARK_RETRACT_FEEDRATE));
+  //if (resume_position.e < 0) unscaled_e_move(resume_position.e, feedRate_t(PAUSE_PARK_RETRACT_FEEDRATE));
  #ifdef ADVANCED_PAUSE_RESUME_PRIME
    if (ADVANCED_PAUSE_RESUME_PRIME != 0)
      unscaled_e_move(ADVANCED_PAUSE_RESUME_PRIME, feedRate_t(ADVANCED_PAUSE_PURGE_FEEDRATE));
@@ -689,7 +698,7 @@ void resume_print(const_float_t slow_load_length/*=0*/, const_float_t fast_load_
  // Now all extrusion positions are resumed and ready to be confirmed
  // Set extruder to saved position
  planner.set_e_position_mm((destination.e = current_position.e = resume_position.e));
-
+  sync_plan_position_e();
  ui.pause_show_message(PAUSE_MESSAGE_STATUS);

  #ifdef ACTION_ON_RESUMED
@@ -52,10 +52,12 @@ enum PauseMessage : char {
  PAUSE_MESSAGE_RESUME,
  PAUSE_MESSAGE_HEAT,
  PAUSE_MESSAGE_HEATING,
-  PAUSE_MESSAGE_STATUS
+  PAUSE_MESSAGE_STATUS,
+  PAUSE_MESSAGE_COUNT
 };

 #if M600_PURGE_MORE_RESUMABLE
+  // Input methods can Purge More, Resume, or request input
  enum PauseMenuResponse : char {
    PAUSE_RESPONSE_WAIT_FOR,
    PAUSE_RESPONSE_EXTRUDE_MORE,
@@ -105,7 +107,7 @@ void wait_for_confirmation(
 void resume_print(
  const_float_t   slow_load_length=0,                         // (mm) Slow Load Length for finishing move
  const_float_t   fast_load_length=0,                         // (mm) Fast Load Length for initial move
-  const_float_t   extrude_length=ADVANCED_PAUSE_PURGE_LENGTH, // (mm) Purge length
+  const_float_t   purge_length=ADVANCED_PAUSE_PURGE_LENGTH,   // (mm) Purge length
  const int8_t    max_beep_count=0,                           // Beep alert for attention
  const celsius_t targetTemp=0                                // (°C) A target temperature for the hotend
  DXC_PARAMS                                                  // Dual-X-Carriage extruder index
@@ -114,7 +116,7 @@ void resume_print(
 bool load_filament(
  const_float_t   slow_load_length=0,                         // (mm) Slow Load Length for finishing move
  const_float_t   fast_load_length=0,                         // (mm) Fast Load Length for initial move
-  const_float_t   extrude_length=0,                           // (mm) Purge length
+  const_float_t   purge_length=0,                             // (mm) Purge length
  const int8_t    max_beep_count=0,                           // Beep alert for attention
  const bool      show_lcd=false,                             // Set LCD status messages?
  const bool      pause_for_user=false,                       // Pause for user before returning?
@@ -34,6 +34,10 @@
 #include "../module/temperature.h"
 #include "../MarlinCore.h"

+#if ENABLED(MAX7219_REINIT_ON_POWERUP)
+  #include "max7219.h"
+#endif
+
 #if ENABLED(PS_OFF_SOUND)
  #include "../libs/buzzer.h"
 #endif
@@ -60,6 +64,10 @@ bool Power::psu_on;
  millis_t Power::lastPowerOn;
 #endif

+#if PSU_TRACK_STATE_MS
+  millis_t Power::last_state_change_ms = 0;
+#endif
+
 /**
 * Initialize pins & state for the power manager.
 *
@@ -87,9 +95,18 @@ void Power::power_on() {
  #endif

  OUT_WRITE(PS_ON_PIN, PSU_ACTIVE_STATE);
+  #if ENABLED(PSU_OFF_REDUNDANT)
+    OUT_WRITE(PS_ON1_PIN, TERN_(PSU_OFF_REDUNDANT_INVERTED, !)PSU_ACTIVE_STATE);
+  #endif
+  TERN_(PSU_TRACK_STATE_MS, last_state_change_ms = millis());
+
  psu_on = true;
  safe_delay(PSU_POWERUP_DELAY);
+
  restore_stepper_drivers();
+
+  TERN_(MAX7219_REINIT_ON_POWERUP, max7219.init());
+
  TERN_(HAS_TRINAMIC_CONFIG, safe_delay(PSU_POWERUP_DELAY));

  #ifdef PSU_POWERUP_GCODE
@@ -102,11 +119,12 @@ void Power::power_on() {
 * Processes any PSU_POWEROFF_GCODE and makes a PS_OFF_SOUND if enabled.
 */
 void Power::power_off() {
-  SERIAL_ECHOLNPGM(STR_POWEROFF);
-
  TERN_(HAS_SUICIDE, suicide());

  if (!psu_on) return;
+  SERIAL_ECHOLNPGM(STR_POWEROFF);
+
+  SERIAL_ECHOLNPGM(STR_POWEROFF);

  #ifdef PSU_POWEROFF_GCODE
    gcode.process_subcommands_now(F(PSU_POWEROFF_GCODE));
@@ -117,6 +135,11 @@ void Power::power_off() {
  #endif

  OUT_WRITE(PS_ON_PIN, !PSU_ACTIVE_STATE);
+  #if ENABLED(PSU_OFF_REDUNDANT)
+    OUT_WRITE(PS_ON1_PIN, IF_DISABLED(PSU_OFF_REDUNDANT_INVERTED, !)PSU_ACTIVE_STATE);
+  #endif
+  TERN_(PSU_TRACK_STATE_MS, last_state_change_ms = millis());
+
  psu_on = false;

  #if ANY(POWER_OFF_TIMER, POWER_OFF_WAIT_FOR_COOLDOWN)
@@ -24,8 +24,11 @@
 /**
 * power.h - power control
 */
+#if PIN_EXISTS(PS_ON_EDM) || (PIN_EXISTS(PS_ON1_EDM) && ENABLED(PSU_OFF_REDUNDANT))
+  #define PSU_TRACK_STATE_MS 1
+#endif

-#if ANY(AUTO_POWER_CONTROL, POWER_OFF_TIMER)
+#if ANY(AUTO_POWER_CONTROL, POWER_OFF_TIMER, PSU_TRACK_STATE_MS)
  #include "../core/millis_t.h"
 #endif

@@ -37,6 +40,10 @@ class Power {
    static void power_on();
    static void power_off();

+    #if PSU_TRACK_STATE_MS
+      static millis_t last_state_change_ms;
+    #endif
+
    #if ANY(POWER_OFF_TIMER, POWER_OFF_WAIT_FOR_COOLDOWN)
      #if ENABLED(POWER_OFF_TIMER)
        static millis_t power_off_time;
@@ -48,8 +48,8 @@ uint8_t PrintJobRecovery::queue_index_r;
 uint32_t PrintJobRecovery::cmd_sdpos, // = 0
         PrintJobRecovery::sdpos[BUFSIZE];

-#if HAS_DWIN_E3V2_BASIC
-  bool PrintJobRecovery::dwin_flag; // = false
+#if HAS_PLR_UI_FLAG
+  bool PrintJobRecovery::ui_flag_resume; // = false
 #endif

 #include "../sd/cardreader.h"
@@ -151,8 +151,8 @@ class PrintJobRecovery {
    static uint32_t cmd_sdpos,        //!< SD position of the next command
                    sdpos[BUFSIZE];   //!< SD positions of queued commands

-    #if HAS_DWIN_E3V2_BASIC
-      static bool dwin_flag;
+    #if HAS_PLR_UI_FLAG
+      static bool ui_flag_resume;     //!< Flag the UI to show a dialog to Resume (M1000) or Cancel (M1000C)
    #endif

    static void init();
@@ -32,9 +32,9 @@

 FilamentMonitor runout;

-bool FilamentMonitorBase::enabled = true,
-     FilamentMonitorBase::filament_ran_out;  // = false
-
+bool FilamentMonitorBase::enabled[NUM_RUNOUT_SENSORS], // Initialized by settings.load
+     FilamentMonitorBase::filament_ran_out; // = false
+RunoutMode FilamentMonitorBase::mode[NUM_RUNOUT_SENSORS]; // Initialized by settings.load
 #if ENABLED(HOST_ACTION_COMMANDS)
  bool FilamentMonitorBase::host_handling; // = false
 #endif
@@ -45,15 +45,10 @@ bool FilamentMonitorBase::enabled = true,
  #include "../core/debug_out.h"
 #endif

-#if HAS_FILAMENT_RUNOUT_DISTANCE
-  float RunoutResponseDelayed::runout_distance_mm = FILAMENT_RUNOUT_DISTANCE_MM;
-  countdown_t RunoutResponseDelayed::mm_countdown;
-  #if ENABLED(FILAMENT_MOTION_SENSOR)
-    uint8_t FilamentSensorEncoder::motion_detected;
-  #endif
-#else
-  int8_t RunoutResponseDebounced::runout_count[NUM_RUNOUT_SENSORS]; // = 0
-#endif
+float RunoutResponseDelayed::runout_distance_mm[NUM_RUNOUT_SENSORS]; // Initialized by settings.load
+countdown_t RunoutResponseDelayed::mm_countdown;
+uint8_t FilamentSensorCore::motion_detected;
+int8_t RunoutResponseDelayed::runout_count[NUM_RUNOUT_SENSORS]; // = 0

 //
 // Filament Runout event handler
@@ -68,8 +63,6 @@ bool FilamentMonitorBase::enabled = true,

 #if ENABLED(EXTENSIBLE_UI)
  #include "../lcd/extui/ui_api.h"
-#elif ENABLED(DWIN_LCD_PROUI)
-  #include "../lcd/e3v2/proui/dwin.h"
 #endif

 void event_filament_runout(const uint8_t extruder) {
@@ -88,7 +81,6 @@ void event_filament_runout(const uint8_t extruder) {
  #endif

  TERN_(EXTENSIBLE_UI, ExtUI::onFilamentRunout(ExtUI::getTool(extruder)));
-  TERN_(DWIN_LCD_PROUI, dwinFilamentRunout(extruder));

  #if ANY(HOST_PROMPT_SUPPORT, HOST_ACTION_COMMANDS, MULTI_FILAMENT_SENSOR)
    const char tool = '0' + TERN0(MULTI_FILAMENT_SENSOR, extruder);
@@ -44,12 +44,6 @@
  #define FILAMENT_RUNOUT_THRESHOLD 5
 #endif

-#if ENABLED(FILAMENT_MOTION_SENSOR)
-  #define HAS_FILAMENT_MOTION 1
-#endif
-#if DISABLED(FILAMENT_MOTION_SENSOR) || ENABLED(FILAMENT_SWITCH_AND_MOTION)
-  #define HAS_FILAMENT_SWITCH 1
-#endif

 typedef Flags<
          #if NUM_MOTION_SENSORS > NUM_RUNOUT_SENSORS
@@ -64,24 +58,37 @@ inline bool should_monitor_runout() { return did_pause_print || printingIsActive

 template<class RESPONSE_T, class SENSOR_T>
 class TFilamentMonitor;
-class FilamentSensor;
+class FilamentSensorCore;
 class RunoutResponseDelayed;
-class RunoutResponseDebounced;

 /********************************* TEMPLATE SPECIALIZATION *********************************/

 typedef TFilamentMonitor<
-          TERN(HAS_FILAMENT_RUNOUT_DISTANCE, RunoutResponseDelayed, RunoutResponseDebounced),
-          FilamentSensor
+          RunoutResponseDelayed,
+          FilamentSensorCore
        > FilamentMonitor;

 extern FilamentMonitor runout;

 /*******************************************************************************************/

+enum RunoutMode : uint8_t {
+  RM_NONE,
+  RM_OUT_ON_LOW,
+  RM_OUT_ON_HIGH,
+  RM_RESERVED3,
+  RM_RESERVED4,
+  RM_RESERVED5,
+  RM_RESERVED6,
+  RM_MOTION_SENSOR
+};
+
 class FilamentMonitorBase {
  public:
-    static bool enabled, filament_ran_out;
+    static bool enabled[NUM_RUNOUT_SENSORS], filament_ran_out;
+    static RunoutMode mode[NUM_RUNOUT_SENSORS];
+
+    static uint8_t out_state(const uint8_t e=0) { return mode[e] == RM_OUT_ON_HIGH ? HIGH : LOW; }

    #if ENABLED(HOST_ACTION_COMMANDS)
      static bool host_handling;
@@ -111,24 +118,14 @@ class TFilamentMonitor : public FilamentMonitorBase {

    // Call this method when filament is present,
    // so the response can reset its counter.
-    static void filament_present(const uint8_t extruder) {
-      response.filament_present(extruder);
-    }
-    #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-      static void filament_motion_present(const uint8_t extruder) {
-        response.filament_motion_present(extruder);
-      }
-    #endif
-
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      static float& runout_distance() { return response.runout_distance_mm; }
-      static void set_runout_distance(const_float_t mm) { response.runout_distance_mm = mm; }
-    #endif
+    static void filament_present(const uint8_t e) { response.filament_present(e); }
+    static float& runout_distance(const uint8_t e=0) { return response.runout_distance_mm[e]; }
+    static void set_runout_distance(const_float_t mm, const uint8_t e=0) { response.runout_distance_mm[e] = mm; }

    // Handle a block completion. RunoutResponseDelayed uses this to
    // add up the length of filament moved while the filament is out.
    static void block_completed(const block_t * const b) {
-      if (enabled) {
+      if (enabled[active_extruder]) {
        response.block_completed(b);
        sensor.block_completed(b);
      }
@@ -137,11 +134,11 @@ class TFilamentMonitor : public FilamentMonitorBase {
    // Give the response a chance to update its counter.
    static void run() {
      if (enabled && !filament_ran_out && should_monitor_runout()) {
-        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, cli()); // Prevent RunoutResponseDelayed::block_completed from accumulating here
+        cli(); // Prevent RunoutResponseDelayed::block_completed from accumulating here
        response.run();
        sensor.run();
        const runout_flags_t runout_flags = response.has_run_out();
-        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, sei());
+        sei();
        #if MULTI_FILAMENT_SENSOR
          #if ENABLED(WATCH_ALL_RUNOUT_SENSORS)
            const bool ran_out = bool(runout_flags);  // any sensor triggers
@@ -182,27 +179,40 @@ class FilamentSensorBase {
    static void filament_present(const uint8_t extruder) {
      runout.filament_present(extruder); // ...which calls response.filament_present(extruder)
    }
-    #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-      static void filament_motion_present(const uint8_t extruder) {
-        runout.filament_motion_present(extruder); // ...which calls response.filament_motion_present(extruder)
-      }
-    #endif

  public:
    static void setup() {
-      #define _INIT_RUNOUT_PIN(P,S,U,D) do{ if (ENABLED(U)) SET_INPUT_PULLUP(P); else if (ENABLED(D)) SET_INPUT_PULLDOWN(P); else SET_INPUT(P); }while(0);
-      #define  INIT_RUNOUT_PIN(N) _INIT_RUNOUT_PIN(FIL_RUNOUT##N##_PIN, FIL_RUNOUT##N##_STATE, FIL_RUNOUT##N##_PULLUP, FIL_RUNOUT##N##_PULLDOWN);
-      REPEAT_1(NUM_RUNOUT_SENSORS, INIT_RUNOUT_PIN)
-      #undef INIT_RUNOUT_PIN
-
-      #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-        #define INIT_MOTION_PIN(N) _INIT_RUNOUT_PIN(FIL_MOTION##N##_PIN, FIL_MOTION##N##_STATE, FIL_MOTION##N##_PULLUP, FIL_MOTION##N##_PULLDOWN);
-        REPEAT_1(NUM_MOTION_SENSORS, INIT_MOTION_PIN)
-        #undef  INIT_MOTION_PIN
+      #define _INIT_RUNOUT_PIN(P,S,U,D) do{ if (ENABLED(U)) SET_INPUT_PULLUP(P); else if (ENABLED(D)) SET_INPUT_PULLDOWN(P); else SET_INPUT(P); }while(0)
+      #define  INIT_RUNOUT_PIN(N) _INIT_RUNOUT_PIN(FIL_RUNOUT##N##_PIN, FIL_RUNOUT##N##_STATE, FIL_RUNOUT##N##_PULLUP, FIL_RUNOUT##N##_PULLDOWN)
+      #if NUM_RUNOUT_SENSORS >= 1
+        INIT_RUNOUT_PIN(1);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 2
+        INIT_RUNOUT_PIN(2);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 3
+        INIT_RUNOUT_PIN(3);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 4
+        INIT_RUNOUT_PIN(4);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 5
+        INIT_RUNOUT_PIN(5);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 6
+        INIT_RUNOUT_PIN(6);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 7
+        INIT_RUNOUT_PIN(7);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 8
+        INIT_RUNOUT_PIN(8);
      #endif
      #undef _INIT_RUNOUT_PIN
+      #undef  INIT_RUNOUT_PIN
    }

+
    // Return a bitmask of runout pin states
    static uint8_t poll_runout_pins() {
      #define _OR_RUNOUT(N) | (READ(FIL_RUNOUT##N##_PIN) ? _BV((N) - 1) : 0)
@@ -212,7 +222,7 @@ class FilamentSensorBase {

    // Return a bitmask of runout flag states (1 bits always indicates runout)
    static uint8_t poll_runout_states() {
-      #define _INVERT_BIT(N) | (FIL_RUNOUT##N##_STATE ? 0 : _BV(N - 1))
+      #define _INVERT_BIT(N) | (runout.out_state(N-1) ? 0 : _BV(N-1))
      return poll_runout_pins() ^ uint8_t(0 REPEAT_1(NUM_RUNOUT_SENSORS, _INVERT_BIT));
      #undef _INVERT_BIT
    }
@@ -234,17 +244,21 @@ class FilamentSensorBase {
    #endif
 };

-#if HAS_FILAMENT_MOTION
+class FilamentSensorCore : public FilamentSensorBase {
+  private:
+    static uint8_t motion_detected;

-  /**
-   * This sensor uses a magnetic encoder disc and a Hall effect
-   * sensor (or a slotted disc and optical sensor). The state
-   * will toggle between 0 and 1 on filament movement. It can detect
-   * filament runout and stripouts or jams.
-   */
-  class FilamentSensorEncoder : public FilamentSensorBase {
-    private:
-      static uint8_t motion_detected;
+    static bool poll_runout_state(const uint8_t extruder) {
+        const uint8_t runout_states = poll_runout_states();
+        #if MULTI_FILAMENT_SENSOR
+          if ( !TERN0(DUAL_X_CARRIAGE, idex_is_duplicating())
+            && !TERN0(MULTI_NOZZLE_DUPLICATION, extruder_duplication_enabled)
+          ) return TEST(runout_states, extruder); // A specific extruder ran out
+        #else
+          UNUSED(extruder);
+        #endif
+        return !!runout_states;                   // Any extruder ran out
+      }

      static void poll_motion_sensor() {
        static uint8_t old_state;
@@ -252,17 +266,17 @@ class FilamentSensorBase {
                      change    = old_state ^ new_state;
        old_state = new_state;

-        #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
-          if (change) {
-            SERIAL_ECHOPGM("Motion detected:");
-            for (uint8_t e = 0; e < TERN(FILAMENT_SWITCH_AND_MOTION, NUM_MOTION_SENSORS, NUM_RUNOUT_SENSORS); ++e)
-              if (TEST(change, e)) SERIAL_CHAR(' ', '0' + e);
-            SERIAL_EOL();
-          }
-        #endif
+      #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
+        if (change) {
+          SERIAL_ECHOPGM("Motion detected:");
+          for(uint8_t e = 0; e < NUM_RUNOUT_SENSORS; ++e)
+            if (TEST(change, e)) SERIAL_CHAR(' ', '0' + e);
+          SERIAL_EOL();
+        }
+      #endif

-        motion_detected |= change;
-      }
+      motion_detected |= change;
+    }

    public:
      static void block_completed(const block_t * const b) {
@@ -275,36 +289,12 @@ class FilamentSensorBase {
        motion_detected = 0;
      }

-      static void run() { poll_motion_sensor(); }
-  };
-
-#endif // HAS_FILAMENT_MOTION
-
-#if HAS_FILAMENT_SWITCH
-
-  /**
-   * This is a simple endstop switch in the path of the filament.
-   * It can detect filament runout, but not stripouts or jams.
-   */
-  class FilamentSensorSwitch : public FilamentSensorBase {
-    private:
-      static bool poll_runout_state(const uint8_t extruder) {
-        const uint8_t runout_states = poll_runout_states();
-        #if MULTI_FILAMENT_SENSOR
-          if ( !TERN0(DUAL_X_CARRIAGE, idex_is_duplicating())
-            && !TERN0(MULTI_NOZZLE_DUPLICATION, extruder_duplication_enabled)
-          ) return TEST(runout_states, extruder); // A specific extruder ran out
-        #else
-          UNUSED(extruder);
-        #endif
-        return !!runout_states;                   // Any extruder ran out
+    static void run() {
+      if (runout.mode[active_extruder] == RM_MOTION_SENSOR) {
+        poll_motion_sensor();
      }
-
-    public:
-      static void block_completed(const block_t * const) {}
-
-      static void run() {
-        for (uint8_t s = 0; s < NUM_RUNOUT_SENSORS; ++s) {
+      else if (runout.mode[active_extruder] != RM_NONE) {
+        for(uint8_t s = 0; s < NUM_RUNOUT_SENSORS; ++s) {
          const bool out = poll_runout_state(s);
          if (!out) filament_present(s);
          #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
@@ -316,36 +306,12 @@ class FilamentSensorBase {
          #endif
        }
      }
-  };
-
- #endif // HAS_FILAMENT_SWITCH
-
-  /**
-   * This is a simple endstop switch in the path of the filament.
-   * It can detect filament runout, but not stripouts or jams.
-   */
-  class FilamentSensor : public FilamentSensorBase {
-    private:
-      TERN_(HAS_FILAMENT_MOTION, static FilamentSensorEncoder encoder_sensor);
-      TERN_(HAS_FILAMENT_SWITCH, static FilamentSensorSwitch switch_sensor);
-
-    public:
-      static void block_completed(const block_t * const b) {
-        TERN_(HAS_FILAMENT_MOTION, encoder_sensor.block_completed(b));
-        TERN_(HAS_FILAMENT_SWITCH, switch_sensor.block_completed(b));
-      }
-
-      static void run() {
-        TERN_(HAS_FILAMENT_MOTION, encoder_sensor.run());
-        TERN_(HAS_FILAMENT_SWITCH, switch_sensor.run());
-      }
-  };
+    }
+};

 /********************************* RESPONSE TYPE *********************************/

-#if HAS_FILAMENT_RUNOUT_DISTANCE
-
-  typedef struct {
+typedef struct {
    float runout[NUM_RUNOUT_SENSORS];
    Flags<NUM_RUNOUT_SENSORS> runout_reset;    // Reset runout later
    #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
@@ -354,15 +320,16 @@ class FilamentSensorBase {
    #endif
  } countdown_t;

-  // RunoutResponseDelayed triggers a runout event only if the length
-  // of filament specified by FILAMENT_RUNOUT_DISTANCE_MM has been fed
-  // during a runout condition.
-  class RunoutResponseDelayed {
-    private:
-      static countdown_t mm_countdown;
+// RunoutResponseDelayed triggers a runout event only if the length
+// of filament specified by FIL_RUNOUT_DISTANCE_MM has been fed
+// during a runout condition.
+class RunoutResponseDelayed {
+  private:
+    static countdown_t mm_countdown;

-    public:
-      static float runout_distance_mm;
+  public:
+    static float runout_distance_mm[NUM_RUNOUT_SENSORS];
+    static int8_t runout_count[NUM_RUNOUT_SENSORS];

      static void reset() {
        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) filament_present(i);
@@ -371,116 +338,33 @@ class FilamentSensorBase {
        #endif
      }

-      static void run() {
-        #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
-          static millis_t t = 0;
-          const millis_t ms = millis();
-          if (ELAPSED(ms, t)) {
-            t = millis() + 1000UL;
-            for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i)
-              SERIAL_ECHO(i ? F(", ") : F("Runout remaining mm: "), mm_countdown.runout[i]);
+    static void run() {
+      #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
+        static millis_t t = 0;
+        const millis_t ms = millis();
+        if (ELAPSED(ms, t)) {
+          t = millis() + 1000UL;
+          for(uint8_t i; i < NUM_RUNOUT_SENSORS; ++i)
+            SERIAL_ECHO(i ? F(", ") : F("Remaining mm: "), mm_countdown[i]);
            #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
              for (uint8_t i = 0; i < NUM_MOTION_SENSORS; ++i)
                SERIAL_ECHO(i ? F(", ") : F("Motion remaining mm: "), mm_countdown.motion[i]);
            #endif
-            SERIAL_EOL();
-          }
-        #endif
-      }
-
-      static runout_flags_t has_run_out() {
-        runout_flags_t runout_flags{0};
-        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) if (mm_countdown.runout[i] < 0) runout_flags.set(i);
-        #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-          for (uint8_t i = 0; i < NUM_MOTION_SENSORS; ++i) if (mm_countdown.motion[i] < 0) runout_flags.set(i);
-        #endif
-        return runout_flags;
-      }
-
-      static void filament_present(const uint8_t extruder) {
-        if (mm_countdown.runout[extruder] < runout_distance_mm || did_pause_print) {
-          // Reset runout only if it is smaller than runout_distance or printing is paused.
-          // On Bowden systems retract may be larger than runout_distance_mm, so if retract
-          // was added leave it in place, or the following unretract will cause runout event.
-          mm_countdown.runout[extruder] = runout_distance_mm;
-          mm_countdown.runout_reset.clear(extruder);
-        }
-        else {
-          // If runout is larger than runout distance, we cannot reset right now, as Bowden and retract
-          // distance larger than runout_distance_mm leads to negative runout right after unretract.
-          // But we cannot ignore filament_present event. After unretract, runout will become smaller
-          // than runout_distance_mm and should be reset after that. So activate delayed reset.
-          mm_countdown.runout_reset.set(extruder);
-        }
-      }
-
-      #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-        static void filament_motion_present(const uint8_t extruder) {
-          // Same logic as filament_present
-          if (mm_countdown.motion[extruder] < runout_distance_mm || did_pause_print) {
-            mm_countdown.motion[extruder] = runout_distance_mm;
-            mm_countdown.motion_reset.clear(extruder);
-          }
-          else
-            mm_countdown.motion_reset.set(extruder);
+          SERIAL_EOL();
        }
      #endif
+    }

-      static void block_completed(const block_t * const b) {
-        const int32_t esteps = b->steps.e;
-        if (!esteps) return;
-
-        // No calculation unless paused or printing
-        if (!should_monitor_runout()) return;
-
-        // No need to ignore retract/unretract movement since they complement each other
-        const uint8_t e = b->extruder;
-        const float mm = (b->direction_bits.e ? esteps : -esteps) * planner.mm_per_step[E_AXIS_N(e)];
-
-        if (e < NUM_RUNOUT_SENSORS) {
-          mm_countdown.runout[e] -= mm;
-          if (mm_countdown.runout_reset[e]) filament_present(e);          // Reset pending. Try to reset.
-        }
-
-        #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-          if (e < NUM_MOTION_SENSORS) {
-            mm_countdown.motion[e] -= mm;
-            if (mm_countdown.motion_reset[e]) filament_motion_present(e); // Reset pending. Try to reset.
-          }
-        #endif
-      }
-  };
-
-#else // !HAS_FILAMENT_RUNOUT_DISTANCE
-
-  // RunoutResponseDebounced triggers a runout event after a runout
-  // condition has been detected runout_threshold times in a row.
-
-  class RunoutResponseDebounced {
-    private:
-      static constexpr int8_t runout_threshold = FILAMENT_RUNOUT_THRESHOLD;
-      static int8_t runout_count[NUM_RUNOUT_SENSORS];
-
-    public:
-      static void reset() {
-        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) filament_present(i);
-      }
-
-      static void run() {
-        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) if (runout_count[i] >= 0) runout_count[i]--;
-      }
-
-      static runout_flags_t has_run_out() {
-        runout_flags_t runout_flags{0};
+    static runout_flags_t has_run_out() {
+      runout_flags_t runout_flags{0};
        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) if (runout_count[i] < 0) runout_flags.set(i);
        return runout_flags;
-      }
+    }

      static void block_completed(const block_t * const) { }

      static void filament_present(const uint8_t extruder) {
-        runout_count[extruder] = runout_threshold;
+        runout_count[extruder] = runout_distance_mm[extruder];
      }
  };

-#endif // !HAS_FILAMENT_RUNOUT_DISTANCE
@@ -763,7 +763,7 @@
        SERIAL_CHAR('\t');
        st.printLabel();
        SERIAL_CHAR('\t');
-        print_hex_long(drv_status, ':');
+        print_hex_long(drv_status, ':', true);
        if (drv_status == 0xFFFFFFFF || drv_status == 0) SERIAL_ECHOPGM("\t Bad response!");
        SERIAL_EOL();
        break;
@@ -144,15 +144,13 @@ class TMCMarlin : public TMC, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
      #endif
    #endif

-    #if ANY(HAS_MARLINUI_MENU, DWIN_LCD_PROUI)
-      void refresh_stepper_current() { rms_current(this->val_mA); }
+    void refresh_stepper_current() { rms_current(this->val_mA); }

-      #if ENABLED(HYBRID_THRESHOLD)
-        void refresh_hybrid_thrs() { set_pwm_thrs(this->stored.hybrid_thrs); }
-      #endif
-      #if USE_SENSORLESS
-        void refresh_homing_thrs() { homing_threshold(this->stored.homing_thrs); }
-      #endif
+    #if ENABLED(HYBRID_THRESHOLD)
+      void refresh_hybrid_thrs() { set_pwm_thrs(this->stored.hybrid_thrs); }
+    #endif
+    #if USE_SENSORLESS
+      void refresh_homing_thrs() { homing_threshold(this->stored.homing_thrs); }
    #endif

    static constexpr int8_t sgt_min = -64,
@@ -207,12 +205,10 @@ class TMCMarlin<TMC2208Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
      }
    #endif

-    #if ANY(HAS_MARLINUI_MENU, DWIN_LCD_PROUI)
-      void refresh_stepper_current() { rms_current(this->val_mA); }
+    void refresh_stepper_current() { rms_current(this->val_mA); }

-      #if ENABLED(HYBRID_THRESHOLD)
-        void refresh_hybrid_thrs() { set_pwm_thrs(this->stored.hybrid_thrs); }
-      #endif
+    #if ENABLED(HYBRID_THRESHOLD)
+      void refresh_hybrid_thrs() { set_pwm_thrs(this->stored.hybrid_thrs); }
    #endif
 };

@@ -269,15 +265,13 @@ class TMCMarlin<TMC2209Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
      }
    #endif

-    #if ANY(HAS_MARLINUI_MENU, DWIN_LCD_PROUI)
-      void refresh_stepper_current() { rms_current(this->val_mA); }
+    void refresh_stepper_current() { rms_current(this->val_mA); }

-      #if ENABLED(HYBRID_THRESHOLD)
-        void refresh_hybrid_thrs() { set_pwm_thrs(this->stored.hybrid_thrs); }
-      #endif
-      #if USE_SENSORLESS
-        void refresh_homing_thrs() { homing_threshold(this->stored.homing_thrs); }
-      #endif
+    #if ENABLED(HYBRID_THRESHOLD)
+      void refresh_hybrid_thrs() { set_pwm_thrs(this->stored.hybrid_thrs); }
+    #endif
+    #if USE_SENSORLESS
+      void refresh_homing_thrs() { homing_threshold(this->stored.homing_thrs); }
    #endif

    static constexpr uint8_t sgt_min = 0,
@@ -315,12 +309,10 @@ class TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC266
      }
    #endif

-    #if ANY(HAS_MARLINUI_MENU, DWIN_LCD_PROUI)
-      void refresh_stepper_current() { rms_current(this->val_mA); }
+    void refresh_stepper_current() { rms_current(this->val_mA); }

-      #if USE_SENSORLESS
-        void refresh_homing_thrs() { homing_threshold(this->stored.homing_thrs); }
-      #endif
+    #if USE_SENSORLESS
+      void refresh_homing_thrs() { homing_threshold(this->stored.homing_thrs); }
    #endif

    static constexpr int8_t sgt_min = -64,
@@ -532,7 +532,7 @@ void GcodeSuite::G26() {

    if (bedtemp) {
      if (!WITHIN(bedtemp, 40, BED_MAX_TARGET)) {
-        SERIAL_ECHOLNPGM("?Specified bed temperature not plausible (40-", BED_MAX_TARGET, "C).");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Specified bed temperature not plausible (40-", BED_MAX_TARGET, "C)."));
        return;
      }
      g26.bed_temp = bedtemp;
@@ -543,7 +543,7 @@ void GcodeSuite::G26() {
  if (parser.seenval('L')) {
    g26.layer_height = parser.value_linear_units();
    if (!WITHIN(g26.layer_height, 0.0, 2.0)) {
-      SERIAL_ECHOLNPGM("?Specified layer height not plausible.");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Specified layer height not plausible."));
      return;
    }
  }
@@ -552,12 +552,12 @@ void GcodeSuite::G26() {
    if (parser.has_value()) {
      g26.retraction_multiplier = parser.value_float();
      if (!WITHIN(g26.retraction_multiplier, 0.05, 15.0)) {
-        SERIAL_ECHOLNPGM("?Specified Retraction Multiplier not plausible.");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Specified Retraction Multiplier not plausible."));
        return;
      }
    }
    else {
-      SERIAL_ECHOLNPGM("?Retraction Multiplier must be specified.");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Retraction Multiplier must be specified."));
      return;
    }
  }
@@ -565,7 +565,7 @@ void GcodeSuite::G26() {
  if (parser.seenval('S')) {
    g26.nozzle = parser.value_float();
    if (!WITHIN(g26.nozzle, 0.1, 2.0)) {
-      SERIAL_ECHOLNPGM("?Specified nozzle size not plausible.");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Specified nozzle size not plausible."));
      return;
    }
  }
@@ -575,7 +575,7 @@ void GcodeSuite::G26() {
      #if HAS_MARLINUI_MENU
        g26.prime_flag = -1;
      #else
-        SERIAL_ECHOLNPGM("?Prime length must be specified when not using an LCD.");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Prime length must be specified when not using an LCD."));
        return;
      #endif
    }
@@ -583,7 +583,7 @@ void GcodeSuite::G26() {
      g26.prime_flag++;
      g26.prime_length = parser.value_linear_units();
      if (!WITHIN(g26.prime_length, 0.0, 25.0)) {
-        SERIAL_ECHOLNPGM("?Specified prime length not plausible.");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Specified prime length not plausible."));
        return;
      }
    }
@@ -592,7 +592,7 @@ void GcodeSuite::G26() {
  if (parser.seenval('F')) {
    g26.filament_diameter = parser.value_linear_units();
    if (!WITHIN(g26.filament_diameter, 1.0, 4.0)) {
-      SERIAL_ECHOLNPGM("?Specified filament size not plausible.");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Specified filament size not plausible."));
      return;
    }
  }
@@ -616,7 +616,7 @@ void GcodeSuite::G26() {
  // If any preset or temperature was specified
  if (noztemp) {
    if (!WITHIN(noztemp, 165, thermalManager.hotend_max_target(active_extruder))) {
-      SERIAL_ECHOLNPGM("?Specified nozzle temperature not plausible.");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Specified nozzle temperature not plausible."));
      return;
    }
    g26.hotend_temp = noztemp;
@@ -637,12 +637,12 @@ void GcodeSuite::G26() {
    if (parser.seen('R'))
      g26_repeats = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS + 1;
    else {
-      SERIAL_ECHOLNPGM("?(R)epeat must be specified when not using an LCD.");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(R)epeat must be specified when not using an LCD."));
      return;
    }
  #endif
  if (g26_repeats < 1) {
-    SERIAL_ECHOLNPGM("?(R)epeat value not plausible; must be at least 1.");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(R)epeat value not plausible; must be at least 1."));
    return;
  }

@@ -650,7 +650,7 @@ void GcodeSuite::G26() {
  g26.xy_pos.set(parser.seenval('X') ? RAW_X_POSITION(parser.value_linear_units()) : current_position.x,
                 parser.seenval('Y') ? RAW_Y_POSITION(parser.value_linear_units()) : current_position.y);
  if (!position_is_reachable(g26.xy_pos)) {
-    SERIAL_ECHOLNPGM("?Specified X,Y coordinate out of bounds.");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Specified X,Y coordinate out of bounds."));
    return;
  }

@@ -64,7 +64,7 @@ void GcodeSuite::G35() {

  const uint8_t screw_thread = parser.byteval('S', TRAMMING_SCREW_THREAD);
  if (!WITHIN(screw_thread, 30, 51) || screw_thread % 10 > 1) {
-    SERIAL_ECHOLNPGM("?(S)crew thread must be 30, 31, 40, 41, 50, or 51.");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(S)crew thread must be 30, 31, 40, 41, 50, or 51."));
    return;
  }

@@ -95,9 +95,11 @@ void GcodeSuite::G35() {
  for (uint8_t i = 0; i < G35_PROBE_COUNT; ++i) {
    const float z_probed_height = probe.probe_at_point(tramming_points[i], PROBE_PT_RAISE);
    if (isnan(z_probed_height)) {
-      SERIAL_ECHO(
-        F("G35 failed at point "), i + 1, F(" ("), FPSTR(pgm_read_ptr(&tramming_point_name[i])), C(')'),
-        FPSTR(SP_X_STR), tramming_points[i].x, FPSTR(SP_Y_STR), tramming_points[i].y
+      SERIAL_ECHOLN(
+        F("G35 failed at point "), i + 1,
+        F(" ("), FPSTR(pgm_read_ptr(&tramming_point_name[i])), C(')'),
+        FPSTR(SP_X_STR), tramming_points[i].x,
+        FPSTR(SP_Y_STR), tramming_points[i].y
      );
      err_break = true;
      break;
@@ -105,13 +105,12 @@ void GcodeSuite::M420() {
        const int16_t a = settings.calc_num_meshes();

        if (!a) {
-          SERIAL_ECHOLNPGM("?EEPROM storage not available.");
+          SERIAL_ECHOLNPGM(GCODE_ERR_MSG("EEPROM storage not available."));
          return;
        }

        if (!WITHIN(storage_slot, 0, a - 1)) {
-          SERIAL_ECHOLNPGM("?Invalid storage slot.");
-          SERIAL_ECHOLNPGM("?Use 0 to ", a - 1);
+          SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Invalid storage slot. Use 0 to ", a - 1));
          return;
        }

@@ -120,7 +119,7 @@ void GcodeSuite::M420() {

      #else

-        SERIAL_ECHOLNPGM("?EEPROM storage not available.");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("EEPROM storage not available."));
        return;

      #endif
@@ -245,6 +244,8 @@ void GcodeSuite::M420() {
 }

 void GcodeSuite::M420_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(
    TERN(MESH_BED_LEVELING, "Mesh Bed Leveling", TERN(AUTO_BED_LEVELING_UBL, "Unified Bed Leveling", "Auto Bed Leveling"))
  ));
@@ -51,8 +51,6 @@
  #include "../../../lcd/extui/ui_api.h"
 #elif ENABLED(DWIN_CREALITY_LCD)
  #include "../../../lcd/e3v2/creality/dwin.h"
-#elif ENABLED(DWIN_LCD_PROUI)
-  #include "../../../lcd/e3v2/proui/dwin.h"
 #endif

 #define DEBUG_OUT ENABLED(DEBUG_LEVELING_FEATURE)
@@ -77,7 +75,7 @@ static void pre_g29_return(const bool retry, const bool did) {
    TERN_(FULL_REPORT_TO_HOST_FEATURE, set_and_report_grblstate(M_IDLE, false));
  }
  if (did) {
-    TERN_(HAS_DWIN_E3V2_BASIC, dwinLevelingDone());
+    TERN_(DWIN_CREALITY_LCD, dwinLevelingDone());
    TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
  }
 }
@@ -344,7 +342,7 @@ G29_TYPE GcodeSuite::G29() {

    abl.verbose_level = parser.intval('V');
    if (!WITHIN(abl.verbose_level, 0, 4)) {
-      SERIAL_ECHOLNPGM("?(V)erbose level implausible (0-4).");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(V)erbose level implausible (0-4)."));
      G29_RETURN(false, false);
    }

@@ -365,11 +363,11 @@ G29_TYPE GcodeSuite::G29() {
      if (parser.seenval('P')) abl.grid_points.x = abl.grid_points.y = parser.value_int();

      if (!WITHIN(abl.grid_points.x, 2, GRID_MAX_POINTS_X)) {
-        SERIAL_ECHOLNPGM("?Probe points (X) implausible (2-" STRINGIFY(GRID_MAX_POINTS_X) ").");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Probe points (X) implausible (2-" STRINGIFY(GRID_MAX_POINTS_X) ")."));
        G29_RETURN(false, false);
      }
      if (!WITHIN(abl.grid_points.y, 2, GRID_MAX_POINTS_Y)) {
-        SERIAL_ECHOLNPGM("?Probe points (Y) implausible (2-" STRINGIFY(GRID_MAX_POINTS_Y) ").");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Probe points (Y) implausible (2-" STRINGIFY(GRID_MAX_POINTS_Y) ")."));
        G29_RETURN(false, false);
      }

@@ -404,7 +402,7 @@ G29_TYPE GcodeSuite::G29() {
          DEBUG_ECHOLNPGM("G29 L", abl.probe_position_lf.x, " R", abl.probe_position_rb.x,
                             " F", abl.probe_position_lf.y, " B", abl.probe_position_rb.y);
        }
-        SERIAL_ECHOLNPGM("? (L,R,F,B) out of bounds.");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG(" (L,R,F,B) out of bounds."));
        G29_RETURN(false, false);
      }

@@ -425,8 +423,6 @@ G29_TYPE GcodeSuite::G29() {
    #if ENABLED(AUTO_BED_LEVELING_3POINT)
      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("> 3-point Leveling");
      points[0].z = points[1].z = points[2].z = 0;  // Probe at 3 arbitrary points
-    #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
-      TERN_(DWIN_LCD_PROUI, dwinLevelingStart());
    #endif

    TERN_(EXTENSIBLE_UI, ExtUI::onLevelingStart());
@@ -436,11 +432,7 @@ G29_TYPE GcodeSuite::G29() {

      #if ENABLED(PREHEAT_BEFORE_LEVELING)
        if (!abl.dryrun) probe.preheat_for_probing(LEVELING_NOZZLE_TEMP,
-          #if ALL(DWIN_LCD_PROUI, HAS_HEATED_BED)
-            hmiData.bedLevT
-          #else
-            LEVELING_BED_TEMP
-          #endif
+          TERN(EXTENSIBLE_UI, ExtUI::getLevelingBedTemp(), LEVELING_BED_TEMP)
        );
      #endif
    }
@@ -993,6 +985,9 @@ G29_TYPE GcodeSuite::G29() {
    process_subcommands_now(F(EVENT_GCODE_AFTER_G29));
  #endif

+  TERN_(HAS_DWIN_E3V2_BASIC, DWIN_LevelingDone());
+  TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
+  TERN_(HAS_MULTI_HOTEND, if (active_extruder != 0) tool_change(0));
  probe.use_probing_tool(false);

  report_current_position();
@@ -40,8 +40,6 @@

 #if ENABLED(EXTENSIBLE_UI)
  #include "../../../lcd/extui/ui_api.h"
-#elif ENABLED(DWIN_LCD_PROUI)
-  #include "../../../lcd/e3v2/proui/dwin.h"
 #endif

 #define DEBUG_OUT ENABLED(DEBUG_LEVELING_FEATURE)
@@ -144,7 +142,6 @@ void GcodeSuite::G29() {
        queue.inject(F("G29S2"));

        TERN_(EXTENSIBLE_UI, ExtUI::onLevelingStart());
-        TERN_(DWIN_LCD_PROUI, dwinLevelingStart());

        return;
      }
@@ -170,7 +167,6 @@ void GcodeSuite::G29() {
        // Save Z for the previous mesh position
        bedlevel.set_zigzag_z(mbl_probe_index - 1, current_position.z);
        TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(ix, iy, current_position.z));
-        TERN_(DWIN_LCD_PROUI, dwinMeshUpdate(_MIN(mbl_probe_index, GRID_MAX_POINTS), int(GRID_MAX_POINTS), current_position.z));
        SET_SOFT_ENDSTOP_LOOSE(false);
      }
      // If there's another point to sample, move there with optional lift.
@@ -237,7 +233,6 @@ void GcodeSuite::G29() {
      if (parser.seenval('Z')) {
        bedlevel.z_values[ix][iy] = parser.value_linear_units();
        TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(ix, iy, bedlevel.z_values[ix][iy]));
-        TERN_(DWIN_LCD_PROUI, dwinMeshUpdate(ix, iy, bedlevel.z_values[ix][iy]));
      }
      else
        return echo_not_entered('Z');
@@ -33,8 +33,6 @@

 #if ENABLED(EXTENSIBLE_UI)
  #include "../../../lcd/extui/ui_api.h"
-#elif ENABLED(DWIN_LCD_PROUI)
-  #include "../../../lcd/e3v2/proui/dwin.h"
 #endif

 /**
@@ -69,7 +67,6 @@ void GcodeSuite::M421() {
    float &zval = bedlevel.z_values[ij.x][ij.y];                          // Altering this Mesh Point
    zval = hasN ? NAN : parser.value_linear_units() + (hasQ ? zval : 0);  // N=NAN, Z=NEWVAL, or Q=ADDVAL
    TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(ij.x, ij.y, zval));          // Ping ExtUI in case it's showing the mesh
-    TERN_(DWIN_LCD_PROUI, dwinMeshUpdate(ij.x, ij.y, zval));
  }
 }

@@ -52,8 +52,6 @@
  #include "../../lcd/extui/ui_api.h"
 #elif ENABLED(DWIN_CREALITY_LCD)
  #include "../../lcd/e3v2/creality/dwin.h"
-#elif ENABLED(DWIN_LCD_PROUI)
-  #include "../../lcd/e3v2/proui/dwin.h"
 #endif

 #if ENABLED(LASER_FEATURE)
@@ -223,7 +221,7 @@ void GcodeSuite::G28() {
    set_and_report_grblstate(M_HOMING);
  #endif

-  TERN_(HAS_DWIN_E3V2_BASIC, dwinHomingStart());
+  TERN_(DWIN_CREALITY_LCD, dwinHomingStart());
  TERN_(EXTENSIBLE_UI, ExtUI::onHomingStart());

  planner.synchronize();          // Wait for planner moves to finish!
@@ -652,7 +650,7 @@ void GcodeSuite::G28() {

  ui.refresh();

-  TERN_(HAS_DWIN_E3V2_BASIC, dwinHomingDone());
+  TERN_(DWIN_CREALITY_LCD, dwinHomingDone());
  TERN_(EXTENSIBLE_UI, ExtUI::onHomingDone());

  report_current_position();
@@ -390,7 +390,7 @@ void GcodeSuite::G33() {

  const int8_t probe_points = parser.intval('P', DELTA_CALIBRATION_DEFAULT_POINTS);
  if (!WITHIN(probe_points, 0, 10)) {
-    SERIAL_ECHOLNPGM("?(P)oints implausible (0-10).");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(P)oints implausible (0-10)."));
    return;
  }

@@ -409,19 +409,19 @@ void GcodeSuite::G33() {

  const float calibration_precision = parser.floatval('C', 0.0f);
  if (calibration_precision < 0) {
-    SERIAL_ECHOLNPGM("?(C)alibration precision implausible (>=0).");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(C)alibration precision implausible (>=0)."));
    return;
  }

  const int8_t force_iterations = parser.intval('F', 0);
  if (!WITHIN(force_iterations, 0, 30)) {
-    SERIAL_ECHOLNPGM("?(F)orce iteration implausible (0-30).");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(F)orce iteration implausible (0-30)."));
    return;
  }

  const int8_t verbose_level = parser.byteval('V', 1);
  if (!WITHIN(verbose_level, 0, 3)) {
-    SERIAL_ECHOLNPGM("?(V)erbose level implausible (0-3).");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(V)erbose level implausible (0-3)."));
    return;
  }

@@ -110,19 +110,19 @@ void GcodeSuite::G34() {

      const int8_t z_auto_align_iterations = parser.intval('I', Z_STEPPER_ALIGN_ITERATIONS);
      if (!WITHIN(z_auto_align_iterations, 1, 30)) {
-        SERIAL_ECHOLNPGM("?(I)teration out of bounds (1-30).");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(I)teration out of bounds (1-30)."));
        break;
      }

      const float z_auto_align_accuracy = parser.floatval('T', Z_STEPPER_ALIGN_ACC);
-      if (!WITHIN(z_auto_align_accuracy, 0.01f, 1.0f)) {
-        SERIAL_ECHOLNPGM("?(T)arget accuracy out of bounds (0.01-1.0).");
+      if (!WITHIN(z_auto_align_accuracy, 0.001f, 1.0f)) {
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(T)arget accuracy out of bounds (0.001-1.0)."));
        break;
      }

      const float z_auto_align_amplification = TERN(HAS_Z_STEPPER_ALIGN_STEPPER_XY, Z_STEPPER_ALIGN_AMP, parser.floatval('A', Z_STEPPER_ALIGN_AMP));
      if (!WITHIN(ABS(z_auto_align_amplification), 0.5f, 2.0f)) {
-        SERIAL_ECHOLNPGM("?(A)mplification out of bounds (0.5-2.0).");
+        SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(A)mplification out of bounds (0.5-2.0)."));
        break;
      }

@@ -450,7 +450,7 @@ void GcodeSuite::M422() {
  const bool is_probe_point = parser.seen_test('S');

  if (TERN0(HAS_Z_STEPPER_ALIGN_STEPPER_XY, is_probe_point && parser.seen_test('W'))) {
-    SERIAL_ECHOLNPGM("?(S) and (W) may not be combined.");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(S) and (W) may not be combined."));
    return;
  }

@@ -460,7 +460,7 @@ void GcodeSuite::M422() {
  );

  if (!is_probe_point && TERN1(HAS_Z_STEPPER_ALIGN_STEPPER_XY, !parser.seen_test('W'))) {
-    SERIAL_ECHOLNPGM("?(S)" TERN_(HAS_Z_STEPPER_ALIGN_STEPPER_XY, " or (W)") " is required.");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(S)" TERN_(HAS_Z_STEPPER_ALIGN_STEPPER_XY, " or (W)") " is required."));
    return;
  }

@@ -490,11 +490,11 @@ void GcodeSuite::M422() {

  if (is_probe_point) {
    if (!probe.can_reach(pos.x, Y_CENTER)) {
-      SERIAL_ECHOLNPGM("?(X) out of bounds.");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(X) out of bounds."));
      return;
    }
    if (!probe.can_reach(pos)) {
-      SERIAL_ECHOLNPGM("?(Y) out of bounds.");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(Y) out of bounds."));
      return;
    }
  }
@@ -503,6 +503,8 @@ void GcodeSuite::M422() {
 }

 void GcodeSuite::M422_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading(forReplay, F(STR_Z_AUTO_ALIGN));
  for (uint8_t i = 0; i < NUM_Z_STEPPERS; ++i) {
    report_echo_start(forReplay);
@@ -106,6 +106,8 @@ void GcodeSuite::M425() {
 }

 void GcodeSuite::M425_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_BACKLASH_COMPENSATION));
  SERIAL_ECHOLNPGM_P(
    PSTR("  M425 F"), backlash.get_correction()
@@ -62,13 +62,13 @@ void GcodeSuite::M48() {

  const int8_t verbose_level = parser.byteval('V', 1);
  if (!WITHIN(verbose_level, 0, 4)) {
-    SERIAL_ECHOLNPGM("?(V)erbose level implausible (0-4).");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("(V)erbose level implausible (0-4)."));
    return;
  }

  const int8_t n_samples = parser.byteval('P', 10);
  if (!WITHIN(n_samples, 4, 50)) {
-    SERIAL_ECHOLNPGM("?Sample size not plausible (4-50).");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Sample size not plausible (4-50)."));
    return;
  }

@@ -82,7 +82,7 @@ void GcodeSuite::M48() {

  if (!probe.can_reach(test_position)) {
    LCD_MESSAGE_MAX(MSG_M48_OUT_OF_BOUNDS);
-    SERIAL_ECHOLNPGM("? (X,Y) out of bounds.");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG(" (X,Y) out of bounds."));
    return;
  }

@@ -90,7 +90,7 @@ void GcodeSuite::M48() {
  bool seen_L = parser.seen('L');
  uint8_t n_legs = seen_L ? parser.value_byte() : 0;
  if (n_legs > 15) {
-    SERIAL_ECHOLNPGM("?Legs of movement implausible (0-15).");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Legs of movement implausible (0-15)."));
    return;
  }
  if (n_legs == 1) n_legs = 2;
@@ -62,6 +62,8 @@
  }

  void GcodeSuite::M665_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading_etc(forReplay, F(STR_DELTA_SETTINGS));
    SERIAL_ECHOLNPGM_P(
        PSTR("  M665 L"), LINEAR_UNIT(delta_diagonal_rod)
@@ -132,6 +134,8 @@
  }

  void GcodeSuite::M665_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading_etc(forReplay, F(STR_SCARA_SETTINGS " (" STR_S_SEG_PER_SEC TERN_(HAS_SCARA_OFFSET, " " STR_SCARA_P_T_Z) ")"));
    SERIAL_ECHOLNPGM_P(
      PSTR("  M665 S"), segments_per_second
@@ -170,6 +174,8 @@
  }

  void GcodeSuite::M665_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading_etc(forReplay, F(STR_POLARGRAPH_SETTINGS));
    SERIAL_ECHOLNPGM_P(
      PSTR("  M665 S"), LINEAR_UNIT(segments_per_second),
@@ -196,10 +202,11 @@
  }

  void GcodeSuite::M665_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
    report_heading_etc(forReplay, F(STR_POLAR_SETTINGS));
    SERIAL_ECHOLNPGM_P(PSTR("  M665 S"), segments_per_second);
  }

-#endif
+#endif // POLAR

 #endif // IS_KINEMATIC
@@ -56,11 +56,13 @@
        }
      }
    }
-    if (is_err) SERIAL_ECHOLNPGM("?M666 offsets must be <= 0");
+    if (is_err) SERIAL_ECHOLNPGM(GCODE_ERR_MSG("M666 offsets must be <= 0"));
    if (!is_set) M666_report();
  }

  void GcodeSuite::M666_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading_etc(forReplay, F(STR_ENDSTOP_ADJUSTMENT));
    SERIAL_ECHOLNPGM_P(
        PSTR("  M666 X"), LINEAR_UNIT(delta_endstop_adj.a)
@@ -105,6 +107,8 @@
  }

  void GcodeSuite::M666_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading_etc(forReplay, F(STR_ENDSTOP_ADJUSTMENT));
    SERIAL_ECHOPGM("  M666");
    #if ENABLED(X_DUAL_ENDSTOPS)
@@ -92,6 +92,8 @@ void GcodeSuite::M852() {
 }

 void GcodeSuite::M852_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_SKEW_FACTOR));
  SERIAL_ECHOPGM("  M852 I", p_float_t(planner.skew_factor.xy, 6));
  #if ENABLED(SKEW_CORRECTION_FOR_Z)
@@ -67,7 +67,7 @@
        if (WITHIN(lval, 0, VOLUMETRIC_EXTRUDER_LIMIT_MAX))
          planner.set_volumetric_extruder_limit(target_extruder, lval);
        else
-          SERIAL_ECHOLNPGM("?L value out of range (0-" STRINGIFY(VOLUMETRIC_EXTRUDER_LIMIT_MAX) ").");
+          SERIAL_ECHOLNPGM(GCODE_ERR_MSG("L value out of range (0-" STRINGIFY(VOLUMETRIC_EXTRUDER_LIMIT_MAX) ")."));
      }
    #endif

@@ -75,6 +75,8 @@
  }

  void GcodeSuite::M200_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    if (!forReplay) {
      report_heading(forReplay, F(STR_FILAMENT_SETTINGS), false);
      if (!parser.volumetric_enabled) SERIAL_ECHOPGM(" (Disabled):");
@@ -142,6 +144,8 @@ void GcodeSuite::M201() {
 }

 void GcodeSuite::M201_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_MAX_ACCELERATION));
  #if NUM_AXES
    SERIAL_ECHOPGM_P(
@@ -198,6 +202,8 @@ void GcodeSuite::M203() {
 }

 void GcodeSuite::M203_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_MAX_FEEDRATES));
  #if NUM_AXES
    SERIAL_ECHOPGM_P(
@@ -255,6 +261,8 @@ void GcodeSuite::M204() {
 }

 void GcodeSuite::M204_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_ACCELERATION_P_R_T));
  SERIAL_ECHOLNPGM_P(
      PSTR("  M204 P"), LINEAR_UNIT(planner.settings.acceleration)
@@ -329,6 +337,8 @@ void GcodeSuite::M205() {
 }

 void GcodeSuite::M205_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(
    "Advanced (" M205_MIN_SEG_TIME_STR "<min_segment_time_us> S<min_feedrate> T<min_travel_feedrate>"
    TERN_(HAS_JUNCTION_DEVIATION, " J<junc_dev>")
@@ -164,6 +164,8 @@ void GcodeSuite::M217() {
 }

 void GcodeSuite::M217_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_TOOL_CHANGING));

  SERIAL_ECHOPGM("  M217");
@@ -63,6 +63,8 @@ void GcodeSuite::M218() {
 }

 void GcodeSuite::M218_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_HOTEND_OFFSETS));
  for (uint8_t e = 1; e < HOTENDS; ++e) {
    report_echo_start(forReplay);
@@ -55,6 +55,8 @@ void GcodeSuite::M281() {
 }

 void GcodeSuite::M281_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_SERVO_ANGLES));
  for (uint8_t i = 0; i < NUM_SERVOS; ++i) {
    switch (i) {
@@ -78,6 +78,8 @@ void GcodeSuite::M301() {
 }

 void GcodeSuite::M301_report(const bool forReplay/*=true*/ E_OPTARG(const int8_t eindex/*=-1*/)) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading(forReplay, F(STR_HOTEND_PID));
  IF_DISABLED(HAS_MULTI_EXTRUDER, constexpr int8_t eindex = -1);
  HOTEND_LOOP() {
@@ -25,12 +25,13 @@
 #if ENABLED(PREVENT_COLD_EXTRUSION)

 #include "../gcode.h"
-#include "../../module/temperature.h"

-#if ENABLED(DWIN_LCD_PROUI)
-  #include "../../lcd/e3v2/proui/dwin.h"
+#if ENABLED(EXTENSIBLE_UI)
+  #include "../../lcd/extui/ui_api.h"
 #endif

+#include "../../module/temperature.h"
+
 /**
 * M302: Allow cold extrudes, or set the minimum extrude temperature
 *
@@ -50,13 +51,14 @@ void GcodeSuite::M302() {
  const bool seen_S = parser.seen('S');
  if (seen_S) {
    thermalManager.extrude_min_temp = parser.value_celsius();
-    thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0);
-    TERN_(DWIN_LCD_PROUI, hmiData.extMinT = thermalManager.extrude_min_temp);
+    TERN_(EXTENSIBLE_UI, ExtUI::onSetMinExtrusionTemp(thermalManager.extrude_min_temp));
  }

-  if (parser.seen('P'))
-    thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0) || parser.value_bool();
-  else if (!seen_S) {
+  const bool seen_P = parser.seen('P');
+  if (seen_P || seen_S) {
+    thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0) || (seen_P && parser.value_bool());
+  }
+  else {
    // Report current state
    SERIAL_ECHO_START();
    SERIAL_ECHOLN(F("Cold extrudes are "), thermalManager.allow_cold_extrude ? F("en") : F("dis"), F("abled (min temp "), thermalManager.extrude_min_temp, F("C)"));
@@ -42,6 +42,8 @@ void GcodeSuite::M304() {
 }

 void GcodeSuite::M304_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_BED_PID));
  SERIAL_ECHOLNPGM("  M304"
      " P", thermalManager.temp_bed.pid.p()
@@ -42,6 +42,8 @@ void GcodeSuite::M309() {
 }

 void GcodeSuite::M309_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_CHAMBER_PID));
  SERIAL_ECHOLNPGM("  M309"
      " P", thermalManager.temp_chamber.pid.p()
@@ -96,6 +96,8 @@ void GcodeSuite::M92() {
 }

 void GcodeSuite::M92_report(const bool forReplay/*=true*/, const int8_t e/*=-1*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_STEPS_PER_UNIT));
  #if NUM_AXES
    #define PRINT_EOL
@@ -66,7 +66,7 @@ void GcodeSuite::M111() {
    SERIAL_ECHOPGM(STR_DEBUG_OFF);
    #if !(defined(__AVR__) && defined(USBCON))
      #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
-        SERIAL_ECHOPGM("\nBuffer Overruns: ", MYSERIAL1.buffer_overruns());
+        //SERIAL_ECHOPGM("\nBuffer Overruns: ", MYSERIAL1.buffer_overruns());
      #endif
      #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
        SERIAL_ECHOPGM("\nFraming Errors: ", MYSERIAL1.framing_errors());
@@ -40,6 +40,8 @@ void GcodeSuite::M211() {
 }

 void GcodeSuite::M211_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_SOFT_ENDSTOPS));
  SERIAL_ECHOPGM("  M211 S", AS_DIGIT(soft_endstop._enabled), " ; ");
  serialprintln_onoff(soft_endstop._enabled);
@@ -79,7 +79,7 @@ void GcodeSuite::M42() {
      #ifdef OUTPUT_OPEN_DRAIN
        case 5: pinMode(pin, OUTPUT_OPEN_DRAIN); break;
      #endif
-      default: SERIAL_ECHOLNPGM("Invalid Pin Mode"); return;
+      default: SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Invalid Pin Mode")); return;
    }
  }

@@ -94,7 +94,7 @@ void GcodeSuite::M42() {
  #endif

  if (avoidWrite) {
-    SERIAL_ECHOLNPGM("?Cannot write to INPUT");
+    SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Cannot write to INPUT"));
    return;
  }

@@ -32,11 +32,16 @@ void GcodeSuite::M85() {
    const millis_t ms = parser.value_millis_from_seconds();
    #if LASER_SAFETY_TIMEOUT_MS > 0
      if (ms && ms <= LASER_SAFETY_TIMEOUT_MS) {
-        SERIAL_ECHO_MSG("M85 timeout must be > ", MS_TO_SEC(LASER_SAFETY_TIMEOUT_MS + 999), " s for laser safety.");
+        SERIAL_ECHO_MSG(GCODE_ERR_MSG("M85 timeout must be > ", MS_TO_SEC(LASER_SAFETY_TIMEOUT_MS + 999), " s for laser safety."));
        return;
      }
    #endif
    max_inactive_time = ms;
  }
+  else {
+    #if DISABLED(MARLIN_SMALL_BUILD)
+      SERIAL_ECHOLNPGM("Inactivity timeout ", MS_TO_SEC(max_inactive_time), " s.");
+    #endif
+  }

 }
@@ -24,8 +24,8 @@

 #if ENABLED(PLATFORM_M997_SUPPORT)

-#if ENABLED(DWIN_LCD_PROUI)
-  #include "../../lcd/e3v2/proui/dwin.h"
+#if ENABLED(EXTENSIBLE_UI)
+  #include "../../lcd/extui/ui_api.h"
 #endif

 /**
@@ -33,7 +33,7 @@
 */
 void GcodeSuite::M997() {

-  TERN_(DWIN_LCD_PROUI, dwinRebootScreen());
+  TERN_(EXTENSIBLE_UI, ExtUI::onFirmwareFlash());

  flashFirmware(parser.intval('S'));

@@ -141,6 +141,8 @@ void GcodeSuite::M900() {
 }

 void GcodeSuite::M900_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading(forReplay, F(STR_LINEAR_ADVANCE));
  #if DISTINCT_E < 2
    report_echo_start(forReplay);
@@ -67,6 +67,8 @@ void GcodeSuite::M710() {
 }

 void GcodeSuite::M710_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_CONTROLLER_FAN));
  SERIAL_ECHOLNPGM("  M710"
    " S", int(controllerFan.settings.active_speed),
@@ -126,12 +126,16 @@ void GcodeSuite::M907() {
 #if HAS_MOTOR_CURRENT_SPI || HAS_MOTOR_CURRENT_PWM

  void GcodeSuite::M907_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading_etc(forReplay, F(STR_STEPPER_MOTOR_CURRENTS));
    #if HAS_MOTOR_CURRENT_PWM
      SERIAL_ECHOLNPGM_P(                                     // PWM-based has 3 values:
          PSTR("  M907 X"), stepper.motor_current_setting[0]  // X, Y, (I, J, K, U, V, W)
        , SP_Z_STR,         stepper.motor_current_setting[1]  // Z
-        , SP_E_STR,         stepper.motor_current_setting[2]  // E
+        #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
+          , SP_E_STR,       stepper.motor_current_setting[2]  // E
+        #endif
      );
    #elif HAS_MOTOR_CURRENT_SPI
      SERIAL_ECHOPGM("  M907");                               // SPI-based has 5 values:
@@ -104,6 +104,8 @@ void say_shaping() {
 }

 void GcodeSuite::M493_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_FT_MOTION));
  const ft_config_t &c = ftMotion.cfg;
  SERIAL_ECHOPGM("  M493 S", c.mode);
@@ -38,6 +38,8 @@
 void GcodeSuite::M207() { fwretract.M207(); }

 void GcodeSuite::M207_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_RETRACT_S_F_Z));
  fwretract.M207_report();
 }
@@ -53,6 +55,8 @@ void GcodeSuite::M207_report(const bool forReplay/*=true*/) {
 void GcodeSuite::M208() { fwretract.M208(); }

 void GcodeSuite::M208_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_RECOVER_S_F));
  fwretract.M208_report();
 }
@@ -68,6 +72,8 @@ void GcodeSuite::M208_report(const bool forReplay/*=true*/) {
  void GcodeSuite::M209() { fwretract.M209(); }

  void GcodeSuite::M209_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading_etc(forReplay, F(STR_AUTO_RETRACT_S));
    fwretract.M209_report();
  }
@@ -28,6 +28,8 @@
 #include "../../../module/stepper.h"

 void GcodeSuite::M593_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F("Input Shaping"));
  #if ENABLED(INPUT_SHAPING_X)
    SERIAL_ECHOLNPGM("  M593 X"
@@ -78,7 +80,7 @@ void GcodeSuite::M593() {
      if (for_Y) stepper.set_shaping_frequency(Y_AXIS, freq);
    }
    else
-      SERIAL_ECHOLNPGM("?Frequency (F) must be greater than ", min_freq, " or 0 to disable");
+      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Frequency (F) must be greater than ", min_freq, " or 0 to disable"));
  }
 }

@@ -97,6 +97,7 @@ void GcodeSuite::M552() {
 }

 void GcodeSuite::M552_report() {
+  TERN_(MARLIN_SMALL_BUILD, return);
  ip_report(552, F("ip address"), Ethernet.linkStatus() == LinkON ? Ethernet.localIP() : ethernet.ip);
 }

@@ -111,6 +112,7 @@ void GcodeSuite::M553() {
 }

 void GcodeSuite::M553_report() {
+  TERN_(MARLIN_SMALL_BUILD, return);
  ip_report(553, F("subnet mask"), Ethernet.linkStatus() == LinkON ? Ethernet.subnetMask() : ethernet.subnet);
 }

@@ -125,6 +127,7 @@ void GcodeSuite::M554() {
 }

 void GcodeSuite::M554_report() {
+  TERN_(MARLIN_SMALL_BUILD, return);
  ip_report(554, F("gateway"), Ethernet.linkStatus() == LinkON ? Ethernet.gatewayIP() : ethernet.gateway);
 }

@@ -28,6 +28,7 @@
 #include "../../../module/stepper.h"

 void GcodeSuite::M592_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
  report_heading(forReplay, F(STR_NONLINEAR_EXTRUSION));
  SERIAL_ECHOLNPGM("  M592 A", stepper.ne.A, " B", stepper.ne.B, " C", stepper.ne.C);
 }
@@ -94,7 +94,7 @@ void GcodeSuite::M600() {
                                   // In this case, for duplicating modes set DXC_ext to the extruder that ran out.
      #if MULTI_FILAMENT_SENSOR
        if (idex_is_duplicating())
-          DXC_ext = (READ(FIL_RUNOUT2_PIN) == FIL_RUNOUT2_STATE) ? 1 : 0;
+          DXC_ext = (READ(FIL_RUNOUT2_PIN) == runout.out_state(1)) ? 1 : 0;
      #else
        DXC_ext = active_extruder;
      #endif
@@ -61,6 +61,8 @@ void GcodeSuite::M603() {
 }

 void GcodeSuite::M603_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading(forReplay, F(STR_FILAMENT_LOAD_UNLOAD));

  #if EXTRUDERS == 1
@@ -37,8 +37,6 @@
  #include "../../../lcd/extui/ui_api.h"
 #elif ENABLED(DWIN_CREALITY_LCD)
  #include "../../../lcd/e3v2/creality/dwin.h"
-#elif ENABLED(DWIN_LCD_PROUI)
-  #include "../../../lcd/e3v2/proui/dwin.h"
 #elif ENABLED(DWIN_CREALITY_LCD_JYERSUI)
  #include "../../../lcd/e3v2/jyersui/dwin.h" // Temporary fix until it can be better implemented
 #endif
@@ -76,12 +74,12 @@ void GcodeSuite::M1000() {
    if (!force_resume && parser.seen_test('S')) {
      #if HAS_MARLINUI_MENU
        ui.goto_screen(menu_job_recovery);
-      #elif HAS_DWIN_E3V2_BASIC
-        recovery.dwin_flag = true;
-      #elif ENABLED(DWIN_CREALITY_LCD_JYERSUI) // Temporary fix until it can be better implemented
-        jyersDWIN.popupHandler(Popup_Resume);
      #elif ENABLED(EXTENSIBLE_UI)
        ExtUI::onPowerLossResume();
+      #elif HAS_PLR_UI_FLAG
+        recovery.ui_flag_resume = true;
+      #elif ENABLED(DWIN_CREALITY_LCD_JYERSUI) // Temporary fix until it can be better implemented
+        jyersDWIN.popupHandler(Popup_Resume);
      #else
        SERIAL_ECHO_MSG("Resume requires LCD.");
      #endif
@@ -64,12 +64,15 @@ void GcodeSuite::M413() {
 }

 void GcodeSuite::M413_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_POWER_LOSS_RECOVERY));
  SERIAL_ECHOPGM("  M413 S", AS_DIGIT(recovery.enabled)
    #if HAS_PLR_BED_THRESHOLD
      , " B", recovery.bed_temp_threshold
    #endif
  );
+  SERIAL_ECHO(" ; ");
  serialprintln_onoff(recovery.enabled);
 }

@@ -28,36 +28,46 @@
 #include "../../../feature/runout.h"

 /**
- * M412: Enable / Disable filament runout detection
+ * M591: Configure filament runout detection
 *
 * Parameters
 *  R         : Reset the runout sensor
 *  S<bool>   : Reset and enable/disable the runout sensor
 *  H<bool>   : Enable/disable host handling of filament runout
- *  D<linear> : Extra distance to continue after runout is triggered
+ *  L<linear> : Extra distance to continue after runout is triggered or motion interval
+ *  D<linear> : Alias for L
+ *  P<index>  : Mode 0 = NONE
+ *                   1 = Switch NO (HIGH = filament present)
+ *                   2 = Switch NC (LOW = filament present)
+ *                   3 = Encoder / Motion Sensor
 */
-void GcodeSuite::M412() {
-  if (parser.seen("RS"
-    TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, "D")
-    TERN_(HOST_ACTION_COMMANDS, "H")
-  )) {
+void GcodeSuite::M591() {
+  if (parser.seen("RSDP" TERN_(HOST_ACTION_COMMANDS, "H"))) {
    #if ENABLED(HOST_ACTION_COMMANDS)
      if (parser.seen('H')) runout.host_handling = parser.value_bool();
    #endif
    const bool seenR = parser.seen_test('R'), seenS = parser.seen('S');
    if (seenR || seenS) runout.reset();
-    if (seenS) runout.enabled = parser.value_bool();
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      if (parser.seenval('D')) runout.set_runout_distance(parser.value_linear_units());
-    #endif
+    const uint8_t tool = TERN0(MULTI_FILAMENT_SENSOR, parser.ushortval('E', active_extruder));
+    if (seenS) runout.enabled[tool] = parser.value_bool();
+    if (parser.seen('D') || parser.seen('L')) runout.set_runout_distance(parser.value_linear_units(), tool);
+    if (parser.seen('P')) {
+      const RunoutMode tmp_mode = (RunoutMode)parser.value_int();
+      switch (tmp_mode) {
+        case RM_NONE ... RM_OUT_ON_HIGH:
+        case RM_MOTION_SENSOR:
+          runout.mode[tool] = tmp_mode;
+          runout.setup();
+        default: break;
+      }
+    }
  }
  else {
    SERIAL_ECHO_START();
    SERIAL_ECHOPGM("Filament runout ");
-    serialprint_onoff(runout.enabled);
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(), "mm");
-    #endif
+    serialprint_onoff(runout.enabled[active_extruder]);
+    SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(active_extruder), "mm");
+    SERIAL_ECHOPGM(" ; Mode ", runout.mode[active_extruder]);
    #if ENABLED(HOST_ACTION_COMMANDS)
      SERIAL_ECHOPGM(" ; Host handling ");
      serialprint_onoff(runout.host_handling);
@@ -66,16 +76,19 @@ void GcodeSuite::M412() {
  }
 }

-void GcodeSuite::M412_report(const bool forReplay/*=true*/) {
+void GcodeSuite::M591_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
  report_heading_etc(forReplay, F(STR_FILAMENT_RUNOUT_SENSOR));
-  SERIAL_ECHOPGM(
-    "  M412 S", runout.enabled
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      , " D", LINEAR_UNIT(runout.runout_distance())
-    #endif
-    , " ; Sensor "
-  );
-  serialprintln_onoff(runout.enabled);
+  for(int e=0; e < NUM_RUNOUT_SENSORS; e++)
+    SERIAL_ECHOLNPGM(
+      "  M591"
+      #if MULTI_FILAMENT_SENSOR
+        " E", e,
+      #endif
+        " S", runout.enabled[e]
+      , " D", LINEAR_UNIT(runout.runout_distance(e))
+      , " P", runout.mode[e]
+    );
 }

 #endif // HAS_FILAMENT_SENSOR
@@ -155,6 +155,8 @@ void GcodeSuite::M569() {
 }

 void GcodeSuite::M569_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading(forReplay, F(STR_DRIVER_STEPPING_MODE));

  auto say_M569 = [](const bool forReplay, FSTR_P const etc=nullptr, const bool eol=false) {
@@ -231,6 +231,8 @@ void GcodeSuite::M906() {
 }

 void GcodeSuite::M906_report(const bool forReplay/*=true*/) {
+  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading(forReplay, F(STR_STEPPER_DRIVER_CURRENT));

  auto say_M906 = [](const bool forReplay) {
@@ -378,6 +378,8 @@
  }

  void GcodeSuite::M913_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading(forReplay, F(STR_HYBRID_THRESHOLD));

    auto say_M913 = [](const bool forReplay) {
@@ -565,6 +567,8 @@
  }

  void GcodeSuite::M914_report(const bool forReplay/*=true*/) {
+    TERN_(MARLIN_SMALL_BUILD, return);
+
    report_heading(forReplay, F(STR_STALLGUARD_THRESHOLD));

    auto say_M914 = [](const bool forReplay) {
--- a/Show More
+++ b/Show More