use has_* naming

use the conditional
Fix FTDUI Status Screen Timeout
2022-10-21 16:39:33 -05:00 · 2022-10-19 21:09:43 -05:00 · 2022-10-18 17:53:07 -04:00
638 changed files with 12071 additions and 47884 deletions
@@ -1,29 +0,0 @@
-# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.187.0/containers/python-3/.devcontainer/base.Dockerfile
-
-# [Choice] Python version: 3, 3.9, 3.8, 3.7, 3.6
-ARG VARIANT="3.9.0-buster"
-FROM python:${VARIANT}
-
-# [Option] Install Node.js
-ARG INSTALL_NODE="true"
-ARG NODE_VERSION="lts/*"
-RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
-
-# [Optional] If your pip requirements rarely change, uncomment this section to add them to the image.
-# COPY requirements.txt /tmp/pip-tmp/
-# RUN pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \
-#    && rm -rf /tmp/pip-tmp
-
-# [Optional] Uncomment this section to install additional OS packages.
-# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-#     && apt-get -y install --no-install-recommends <your-package-list-here>
-
-# [Optional] Uncomment this line to install global node packages.
-# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1
-
-
-RUN pip install -U https://github.com/platformio/platformio-core/archive/develop.zip
-RUN platformio update
-# To get the test platforms
-RUN pip install PyYaml
-#ENV PATH /code/buildroot/bin/:/code/buildroot/tests/:${PATH}
@@ -1,51 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
-// https://github.com/microsoft/vscode-dev-containers/tree/v0.187.0/containers/python-3
-{
-  "name": "Python 3",
-  "build": {
-    "dockerfile": "Dockerfile",
-    "context": "..",
-    "args": {
-      // Update 'VARIANT' to pick a Python version: 3, 3.6, 3.7, 3.8, 3.9
-      "VARIANT": "3.9.0-buster",
-      // Options
-      "INSTALL_NODE": "false",
-      "NODE_VERSION": "lts/*"
-    }
-  },
-
-  // Set *default* container specific settings.json values on container create.
-  "settings": {
-    "python.pythonPath": "/usr/local/bin/python",
-    "python.languageServer": "Pylance",
-    "python.linting.enabled": true,
-    "python.linting.pylintEnabled": true,
-    "python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
-    "python.formatting.blackPath": "/usr/local/py-utils/bin/black",
-    "python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
-    "python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
-    "python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
-    "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
-    "python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
-    "python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
-    "python.linting.pylintPath": "/usr/local/py-utils/bin/pylint"
-  },
-
-  // Add the IDs of extensions you want installed when the container is created.
-  "extensions": [
-    "ms-python.python",
-    "ms-python.vscode-pylance",
-    "platformio.platformio-ide",
-    "marlinfirmware.auto-build",
-    "editorconfig.editorconfig"
-  ],
-
-  // Use 'forwardPorts' to make a list of ports inside the container available locally.
-  // "forwardPorts": [],
-
-  // Use 'postCreateCommand' to run commands after the container is created.
-  // "postCreateCommand": "pip3 install --user -r requirements.txt",
-
-  // Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-  // "remoteUser": "vscode"
-}
@@ -29,6 +29,6 @@ jobs:

          Please redo this PR starting with the `bugfix-2.1.x` branch and be careful to target `bugfix-2.1.x` when resubmitting the PR. Patches may also target `bugfix-2.0.x` if they are specifically for 2.0.9.x.

-          It may help to set your fork's default branch to `bugfix-2.1.x`.
+          It may help to set your fork's default branch to `bugfix-2.0.x`.

          See [this page](https://marlinfw.org/docs/development/getting_started_pull_requests.html) for full instructions.
@@ -44,7 +44,6 @@ jobs:
        - teensy31
        - teensy35
        - teensy41
-        - SAMD21_minitronics20
        - SAMD51_grandcentral_m4
        - PANDA_PI_V29

@@ -21,8 +21,7 @@

 # Generated files
 _Version.h
-bdf2u8g.exe
-genpages.exe
+bdf2u8g
 marlin_config.json
 mczip.h
 *.gen
@@ -307,22 +307,20 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1154)
 else ifeq ($(HARDWARE_MOTHERBOARD),1155)
 # Tenlog D3 Hero IDEX printer
 else ifeq ($(HARDWARE_MOTHERBOARD),1156)
-# Tenlog D3,5,6 Pro IDEX printers
-else ifeq ($(HARDWARE_MOTHERBOARD),1157)
 # Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1158)
+else ifeq ($(HARDWARE_MOTHERBOARD),1157)
 # Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Hotend2, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1159)
+else ifeq ($(HARDWARE_MOTHERBOARD),1158)
 # Ramps S 1.2 by Sakul.cz (Power outputs: Hotend, Fan0, Fan1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1160)
+else ifeq ($(HARDWARE_MOTHERBOARD),1159)
 # Longer LK1 PRO / Alfawise U20 Pro (PRO version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1161)
+else ifeq ($(HARDWARE_MOTHERBOARD),1160)
 # Longer LKx PRO / Alfawise Uxx Pro (PRO version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1162)
+else ifeq ($(HARDWARE_MOTHERBOARD),1161)
 # Zonestar zrib V5.3 (Chinese RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1163)
+else ifeq ($(HARDWARE_MOTHERBOARD),1162)
 # Pxmalion Core I3
-else ifeq ($(HARDWARE_MOTHERBOARD),1164)
+else ifeq ($(HARDWARE_MOTHERBOARD),1163)

 #
 # RAMBo and derivatives
@@ -1,6 +1,6 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
 * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -28,25 +28,25 @@
 /**
 * Marlin release version identifier
 */
-#define SHORT_BUILD_VERSION "bugfix-2.1.x_R01"
+//#define SHORT_BUILD_VERSION "bugfix-2.1.x"

 /**
 * 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 " TM3D"
+//#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION

 /**
 * 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 "2023-03-10"
+//#define STRING_DISTRIBUTION_DATE "2022-10-18"

 /**
 * Defines a generic printer name to be output to the LCD after booting Marlin.
 */
-#define MACHINE_NAME "TM3D Raptor"
+//#define MACHINE_NAME "3D Printer"

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

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

 /**
 * Set the vendor info the serial USB interface, if changable
@@ -1,105 +0,0 @@
-/**
- * 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_BMPHEIGHT 64
-
-const unsigned char custom_start_bmp[] PROGMEM = {
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFD, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFD, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFE, 0x07, 0xC0, 0x05, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFC, 0x0A, 0x20, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFE, 0x14, 0x10, 0x05, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFC, 0x28, 0x08, 0x06, 0x07, 0xC0, 0x05, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F, 0xFF, 0xFF, 0xFF,
-0xFE, 0x54, 0x04, 0x04, 0x0A, 0x20, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF,
-0xFC, 0x60, 0x04, 0x06, 0x14, 0x10, 0x05, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFE, 0x50, 0x04, 0x04, 0x28, 0x08, 0x06, 0x07, 0xC0, 0x05, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F,
-0xFC, 0x60, 0x04, 0x06, 0x54, 0x04, 0x04, 0x0A, 0x20, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
-0xFE, 0x54, 0x04, 0x1C, 0x60, 0x04, 0x06, 0x14, 0x10, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
-0xFC, 0x28, 0x08, 0x2E, 0x50, 0x04, 0x04, 0x28, 0x08, 0x06, 0x07, 0xC0, 0x00, 0x01, 0xF0, 0x3F,
-0xFE, 0x14, 0x10, 0x54, 0x60, 0x04, 0x06, 0x54, 0x04, 0x04, 0x0A, 0x20, 0x00, 0x02, 0x08, 0x1F,
-0xFC, 0x0A, 0x20, 0x66, 0x54, 0x04, 0x1C, 0x60, 0x04, 0x06, 0x14, 0x10, 0x00, 0x05, 0x04, 0x3F,
-0xFE, 0x07, 0xC0, 0x54, 0x28, 0x08, 0x2E, 0x50, 0x04, 0x04, 0x28, 0x08, 0x00, 0x0A, 0x02, 0x1F,
-0xFC, 0x00, 0x00, 0x2E, 0x14, 0x10, 0x54, 0x60, 0x04, 0x06, 0x54, 0x04, 0x00, 0x15, 0x01, 0x3F,
-0xFE, 0x00, 0x00, 0x1C, 0x0A, 0x20, 0x66, 0x54, 0x04, 0x1C, 0x60, 0x04, 0x00, 0x18, 0x01, 0x1F,
-0xFC, 0x00, 0x00, 0x06, 0x07, 0xC0, 0x54, 0x28, 0x08, 0x2E, 0x50, 0x04, 0x00, 0x14, 0x01, 0x3F,
-0xFE, 0x00, 0x00, 0x04, 0x00, 0x00, 0x2E, 0x14, 0x10, 0x54, 0x60, 0x04, 0x00, 0x18, 0x01, 0x1F,
-0xFC, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x1C, 0x0A, 0x20, 0x66, 0x54, 0x04, 0x1C, 0x15, 0x01, 0x3F,
-0xFE, 0xD5, 0x55, 0x54, 0x00, 0x00, 0x06, 0x07, 0xC0, 0x54, 0x28, 0x08, 0x2A, 0x0A, 0x02, 0x1F,
-0xFC, 0x84, 0x10, 0x46, 0x00, 0x00, 0x04, 0x00, 0x00, 0x2E, 0x14, 0x10, 0x51, 0x05, 0x04, 0x3F,
-0xFE, 0xC4, 0x10, 0x44, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x1C, 0x0A, 0x20, 0x61, 0x02, 0x88, 0x1F,
-0xFC, 0x84, 0x10, 0x46, 0xD5, 0x55, 0x54, 0x00, 0x00, 0x06, 0x07, 0xC0, 0x51, 0x01, 0xF0, 0x3F,
-0xFE, 0x84, 0x10, 0x44, 0x84, 0x10, 0x46, 0x00, 0x00, 0x04, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x1F,
-0xFC, 0xC4, 0x10, 0x46, 0xC4, 0x10, 0x44, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x3F,
-0xFE, 0x84, 0x10, 0x44, 0x84, 0x10, 0x46, 0xD5, 0x55, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
-0xFC, 0xD5, 0x55, 0x56, 0x84, 0x10, 0x44, 0x84, 0x10, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
-0xFC, 0xFF, 0xFF, 0xFC, 0xC4, 0x10, 0x46, 0xC4, 0x10, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F,
-0xFE, 0x00, 0x00, 0x06, 0x84, 0x10, 0x44, 0x84, 0x10, 0x46, 0xD5, 0x55, 0x55, 0x55, 0x55, 0xBF,
-0xFD, 0x55, 0x55, 0x54, 0xD5, 0x55, 0x56, 0x84, 0x10, 0x44, 0x84, 0x10, 0x41, 0x04, 0x10, 0x9F,
-0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFC, 0xC4, 0x10, 0x46, 0xC4, 0x10, 0x41, 0x04, 0x11, 0xBF,
-0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x06, 0x84, 0x10, 0x44, 0x84, 0x10, 0x41, 0x04, 0x10, 0x9F,
-0xFF, 0xFF, 0xFF, 0xFD, 0x55, 0x55, 0x54, 0xD5, 0x55, 0x56, 0x84, 0x10, 0x41, 0x04, 0x10, 0x9F,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFC, 0xC4, 0x10, 0x41, 0x04, 0x11, 0xBF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x06, 0x84, 0x10, 0x41, 0x04, 0x10, 0x9F,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0x55, 0x55, 0x54, 0xD5, 0x55, 0x55, 0x55, 0x55, 0xBF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xE0, 0x2E, 0xFB, 0x7D, 0xFB, 0xFB, 0xCF, 0xC1, 0xDF, 0xBB, 0x3E, 0xC0, 0xE1, 0xFE, 0x3C, 0x1F,
-0xFD, 0xEE, 0x7B, 0x39, 0xF9, 0xF3, 0xCF, 0x9E, 0xDF, 0xBB, 0x3E, 0xDF, 0xDE, 0xFC, 0xDD, 0xE7,
-0xFD, 0xEE, 0x3B, 0xBB, 0xF9, 0xEB, 0xD7, 0xBF, 0x5F, 0xBB, 0x5E, 0xDF, 0xDE, 0xFD, 0xED, 0xF7,
-0xFD, 0xEE, 0xBB, 0xD3, 0xFA, 0xEB, 0xB7, 0x3F, 0xDF, 0xBB, 0x4E, 0xDF, 0xDF, 0xFF, 0xCD, 0xF3,
-0xFD, 0xEE, 0xDB, 0xC7, 0xFA, 0xEB, 0xBB, 0x7F, 0xC0, 0x3B, 0x6E, 0xC0, 0xE3, 0xFF, 0x1D, 0xF3,
-0xFD, 0xEE, 0xCB, 0xEF, 0xFA, 0xDB, 0xBB, 0x7F, 0xDF, 0xBB, 0x66, 0xDF, 0xF8, 0xFF, 0xCD, 0xF3,
-0xFD, 0xEE, 0xEB, 0xEF, 0xFB, 0x5B, 0x03, 0x3F, 0x5F, 0xBB, 0x76, 0xDF, 0xFE, 0x7F, 0xED, 0xF3,
-0xFD, 0xEE, 0xF3, 0xEF, 0xFB, 0x5B, 0x79, 0xBE, 0xDF, 0xBB, 0x7A, 0xDF, 0xDE, 0x7D, 0xED, 0xF7,
-0xFD, 0xEE, 0xF3, 0xEF, 0xFB, 0xBA, 0xFD, 0x9E, 0xDF, 0xBB, 0x7C, 0xDF, 0xDE, 0xFD, 0xCD, 0xE7,
-0xFD, 0xEE, 0xFB, 0xEF, 0xFB, 0xBA, 0xFD, 0xC1, 0xDF, 0xBB, 0x7E, 0xC0, 0xE0, 0xFE, 0x1C, 0x1F,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-};
-
-
-
@@ -1,74 +0,0 @@
-/**
- * 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
@@ -95,10 +95,10 @@ invert_y_dir                             = true
 invert_z_dir                             = false
 invert_e0_dir                            = false

-step_state_e                             = HIGH
-step_state_x                             = HIGH
-step_state_y                             = HIGH
-step_state_z                             = HIGH
+invert_e_step_pin                        = false
+invert_x_step_pin                        = false
+invert_y_step_pin                        = false
+invert_z_step_pin                        = false

 disable_x                                = false
 disable_y                                = false
@@ -178,7 +178,7 @@ autotemp_oldweight                       = 0.98
 bed_check_interval                       = 5000
 default_stepper_deactive_time            = 120
 default_volumetric_extruder_limit        = 0.00
-disable_inactive_extruder                = true
+disable_inactive_e                       = true
 disable_inactive_x                       = true
 disable_inactive_y                       = true
 disable_inactive_z                       = true
@@ -32,7 +32,6 @@
  #include <HardwareSerial.h>
 #else
  #include "MarlinSerial.h"
-  #define BOARD_NO_NATIVE_USB
 #endif

 #include <stdint.h>
@@ -107,36 +106,36 @@ typedef Servo hal_servo_t;

  #define MYSERIAL1 TERN(BLUETOOTH, btSerial, MSerial0)
 #else
-  #if !WITHIN(SERIAL_PORT, 0, 3)
-    #error "SERIAL_PORT must be from 0 to 3."
+  #if !WITHIN(SERIAL_PORT, -1, 3)
+    #error "SERIAL_PORT must be from 0 to 3, or -1 for USB Serial."
  #endif
  #define MYSERIAL1 customizedSerial1

  #ifdef SERIAL_PORT_2
-    #if !WITHIN(SERIAL_PORT_2, 0, 3)
-      #error "SERIAL_PORT_2 must be from 0 to 3."
+    #if !WITHIN(SERIAL_PORT_2, -1, 3)
+      #error "SERIAL_PORT_2 must be from 0 to 3, or -1 for USB Serial."
    #endif
    #define MYSERIAL2 customizedSerial2
  #endif

  #ifdef SERIAL_PORT_3
-    #if !WITHIN(SERIAL_PORT_3, 0, 3)
-      #error "SERIAL_PORT_3 must be from 0 to 3."
+    #if !WITHIN(SERIAL_PORT_3, -1, 3)
+      #error "SERIAL_PORT_3 must be from 0 to 3, or -1 for USB Serial."
    #endif
    #define MYSERIAL3 customizedSerial3
  #endif
 #endif

 #ifdef MMU2_SERIAL_PORT
-  #if !WITHIN(MMU2_SERIAL_PORT, 0, 3)
-    #error "MMU2_SERIAL_PORT must be from 0 to 3"
+  #if !WITHIN(MMU2_SERIAL_PORT, -1, 3)
+    #error "MMU2_SERIAL_PORT must be from 0 to 3, or -1 for USB Serial."
  #endif
  #define MMU2_SERIAL mmuSerial
 #endif

 #ifdef LCD_SERIAL_PORT
-  #if !WITHIN(LCD_SERIAL_PORT, 0, 3)
-    #error "LCD_SERIAL_PORT must be from 0 to 3."
+  #if !WITHIN(LCD_SERIAL_PORT, -1, 3)
+    #error "LCD_SERIAL_PORT must be from 0 to 3, or -1 for USB Serial."
  #endif
  #define LCD_SERIAL lcdSerial
  #if HAS_DGUS_LCD
@@ -34,7 +34,6 @@
 #include <WString.h>

 #include "../../inc/MarlinConfigPre.h"
-#include "../../core/types.h"
 #include "../../core/serial_hook.h"

 #ifndef SERIAL_PORT
@@ -139,6 +138,10 @@

  #define BYTE 0

+  // Templated type selector
+  template<bool b, typename T, typename F> struct TypeSelector { typedef T type;} ;
+  template<typename T, typename F> struct TypeSelector<false, T, F> { typedef F type; };
+
  template<typename Cfg>
  class MarlinSerial {
  protected:
@@ -161,7 +164,7 @@
    static constexpr B_U2Xx<Cfg::PORT>   B_U2X   = 0;

    // Base size of type on buffer size
-    typedef uvalue_t(Cfg::RX_SIZE - 1) ring_buffer_pos_t;
+    typedef typename TypeSelector<(Cfg::RX_SIZE>256), uint16_t, uint8_t>::type ring_buffer_pos_t;

    struct ring_buffer_r {
      volatile ring_buffer_pos_t head, tail;
@@ -23,10 +23,6 @@

 #include "../../inc/MarlinConfig.h"

-//#define DEBUG_AVR_FAST_PWM
-#define DEBUG_OUT ENABLED(DEBUG_AVR_FAST_PWM)
-#include "../../core/debug_out.h"
-
 struct Timer {
  volatile uint8_t* TCCRnQ[3];  // max 3 TCCR registers per timer
  volatile uint16_t* OCRnQ[3];  // max 3 OCR registers per timer
@@ -112,15 +108,12 @@ const Timer get_pwm_timer(const pin_t pin) {
 }

 void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
-  DEBUG_ECHOLNPGM("set_pwm_frequency(pin=", pin, ", freq=", f_desired, ")");
  const Timer timer = get_pwm_timer(pin);
  if (timer.isProtected || !timer.isPWM) return; // Don't proceed if protected timer or not recognized

  const bool is_timer2 = timer.n == 2;
  const uint16_t maxtop = is_timer2 ? 0xFF : 0xFFFF;

-  DEBUG_ECHOLNPGM("maxtop=", maxtop);
-
  uint16_t res = 0xFF;        // resolution (TOP value)
  uint8_t j = CS_NONE;        // prescaler index
  uint8_t wgm = WGM_PWM_PC_8; // waveform generation mode
@@ -128,29 +121,23 @@ void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
  // Calculating the prescaler and resolution to use to achieve closest frequency
  if (f_desired != 0) {
    constexpr uint16_t prescaler[] = { 1, 8, (32), 64, (128), 256, 1024 };  // (*) are Timer 2 only
-    uint16_t f = (F_CPU) / (uint32_t(maxtop) << 11) + 1;      // Start with the lowest non-zero frequency achievable (for 16MHz, 1 or 31)
+    uint16_t f = (F_CPU) / (2 * 1024 * maxtop) + 1;           // Start with the lowest non-zero frequency achievable (1 or 31)

-    DEBUG_ECHOLNPGM("f=", f);
-    DEBUG_ECHOLNPGM("(prescaler loop)");
    LOOP_L_N(i, COUNT(prescaler)) {                           // Loop through all prescaler values
-      const uint32_t p = prescaler[i];                        // Extend to 32 bits for calculations
-      DEBUG_ECHOLNPGM("prescaler[", i, "]=", p);
+      const uint16_t p = prescaler[i];
      uint16_t res_fast_temp, res_pc_temp;
      if (is_timer2) {
        #if ENABLED(USE_OCR2A_AS_TOP)                         // No resolution calculation for TIMER2 unless enabled USE_OCR2A_AS_TOP
          const uint16_t rft = (F_CPU) / (p * f_desired);
          res_fast_temp = rft - 1;
          res_pc_temp = rft / 2;
-          DEBUG_ECHOLNPGM("(Timer2) res_fast_temp=", res_fast_temp, " res_pc_temp=", res_pc_temp);
        #else
          res_fast_temp = res_pc_temp = maxtop;
-          DEBUG_ECHOLNPGM("(Timer2) res_fast_temp=", maxtop, " res_pc_temp=", maxtop);
        #endif
      }
      else {
        if (p == 32 || p == 128) continue;                    // Skip TIMER2 specific prescalers when not TIMER2
        const uint16_t rft = (F_CPU) / (p * f_desired);
-        DEBUG_ECHOLNPGM("(Not Timer 2) F_CPU=" STRINGIFY(F_CPU), " prescaler=", p, " f_desired=", f_desired);
        res_fast_temp = rft - 1;
        res_pc_temp = rft / 2;
      }
@@ -159,28 +146,24 @@ void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
      LIMIT(res_pc_temp, 1U, maxtop);

      // Calculate frequencies of test prescaler and resolution values
-      const uint16_t f_fast_temp = (F_CPU) / (p * (1 + res_fast_temp)),
-                     f_pc_temp   = (F_CPU) / ((p * res_pc_temp) << 1),
-                     f_diff      = _MAX(f, f_desired) - _MIN(f, f_desired),
+      const uint32_t f_diff      = _MAX(f, f_desired) - _MIN(f, f_desired),
+                     f_fast_temp = (F_CPU) / (p * (1 + res_fast_temp)),
                     f_fast_diff = _MAX(f_fast_temp, f_desired) - _MIN(f_fast_temp, f_desired),
+                     f_pc_temp   = (F_CPU) / (2 * p * res_pc_temp),
                     f_pc_diff   = _MAX(f_pc_temp, f_desired) - _MIN(f_pc_temp, f_desired);

-      DEBUG_ECHOLNPGM("f_fast_temp=", f_fast_temp, " f_pc_temp=", f_pc_temp, " f_diff=", f_diff, " f_fast_diff=", f_fast_diff, " f_pc_diff=", f_pc_diff);
-
      if (f_fast_diff < f_diff && f_fast_diff <= f_pc_diff) { // FAST values are closest to desired f
        // Set the Wave Generation Mode to FAST PWM
        wgm = is_timer2 ? uint8_t(TERN(USE_OCR2A_AS_TOP, WGM2_FAST_PWM_OCR2A, WGM2_FAST_PWM)) : uint8_t(WGM_FAST_PWM_ICRn);
        // Remember this combination
        f = f_fast_temp; res = res_fast_temp; j = i + 1;
-        DEBUG_ECHOLNPGM("(FAST) updated f=", f);
      }
      else if (f_pc_diff < f_diff) {                          // PHASE CORRECT values are closes to desired f
        // Set the Wave Generation Mode to PWM PHASE CORRECT
        wgm = is_timer2 ? uint8_t(TERN(USE_OCR2A_AS_TOP, WGM2_PWM_PC_OCR2A, WGM2_PWM_PC)) : uint8_t(WGM_PWM_PC_ICRn);
        f = f_pc_temp; res = res_pc_temp; j = i + 1;
-        DEBUG_ECHOLNPGM("(PHASE) updated f=", f);
      }
-    } // prescaler loop
+    }
  }

  _SET_WGMnQ(timer, wgm);
@@ -293,11 +293,11 @@ enum ClockSource2 : uint8_t {

 #if HAS_MOTOR_CURRENT_PWM
  #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E_PIN || P == MOTOR_CURRENT_PWM_E0_PIN  || P == MOTOR_CURRENT_PWM_E1_PIN || P == MOTOR_CURRENT_PWM_Z_PIN || P == MOTOR_CURRENT_PWM_XY_PIN)
+    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_E0  || P == MOTOR_CURRENT_PWM_E1 || P == MOTOR_CURRENT_PWM_Z || P == MOTOR_CURRENT_PWM_XY)
  #elif PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E_PIN || P == MOTOR_CURRENT_PWM_E0_PIN  || P == MOTOR_CURRENT_PWM_E1_PIN || P == MOTOR_CURRENT_PWM_Z_PIN)
+    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_E0  || P == MOTOR_CURRENT_PWM_E1 || P == MOTOR_CURRENT_PWM_Z)
  #else
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E_PIN || P == MOTOR_CURRENT_PWM_E0_PIN  || P == MOTOR_CURRENT_PWM_E1_PIN)
+    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_E0  || P == MOTOR_CURRENT_PWM_E1)
  #endif
 #else
  #define PWM_CHK_MOTOR_CURRENT(P) false
@@ -40,15 +40,13 @@
 #if SERIAL_IN_USE(0)
  // D0-D1. No known conflicts.
 #endif
-#if SERIAL_IN_USE(1)
-  #if NOT_TARGET(__AVR_ATmega644P__, __AVR_ATmega1284P__)
-    #if CHECK_SERIAL_PIN(18) || CHECK_SERIAL_PIN(19)
-      #error "Serial Port 1 pin D18 and/or D19 conflicts with another pin on the board."
-    #endif
-  #else
-    #if CHECK_SERIAL_PIN(10) || CHECK_SERIAL_PIN(11)
-      #error "Serial Port 1 pin D10 and/or D11 conflicts with another pin on the board."
-    #endif
+#if NOT_TARGET(__AVR_ATmega644P__, __AVR_ATmega1284P__)
+  #if SERIAL_IN_USE(1) && (CHECK_SERIAL_PIN(18) || CHECK_SERIAL_PIN(19))
+    #error "Serial Port 1 pin D18 and/or D19 conflicts with another pin on the board."
+  #endif
+#else
+  #if SERIAL_IN_USE(1) && (CHECK_SERIAL_PIN(10) || CHECK_SERIAL_PIN(11))
+    #error "Serial Port 1 pin D10 and/or D11 conflicts with another pin on the board."
  #endif
 #endif
 #if SERIAL_IN_USE(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
@@ -27,14 +27,13 @@

 // intRes = longIn1 * longIn2 >> 24
 // uses:
-// r1, r0 for the result of mul.
-// [tmp1] to store 0.
-// [tmp2] to store bits 16-23 of the 56 bit result. The top bit of [tmp2] is used for rounding.
-// Note that the lower two bytes and the upper two bytes of the 56 bit result are not calculated.
-// This can cause the result to be out by one as the lower bytes may cause carries into the upper ones.
-// [intRes] (A B) is bits 24-39 and is the returned value.
-// [longIn1] (C B A) is a 24 bit parameter.
-// [longIn2] (D C B A) is a 32 bit parameter.
+// A[tmp] to store 0
+// B[tmp] to store bits 16-23 of the 48bit result. The top bit is used to round the two byte result.
+// note that the lower two bytes and the upper byte of the 48bit result are not calculated.
+// this can cause the result to be out by one as the lower bytes may cause carries into the upper ones.
+// B A are bits 24-39 and are the returned value
+// C B A is longIn1
+// D C B A is longIn2
 //
 FORCE_INLINE static uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2) {
  uint8_t tmp1;
@@ -67,9 +66,11 @@ FORCE_INLINE static uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2
    A("add %[tmp2], r1")
    A("adc %A[intRes], %[tmp1]")
    A("adc %B[intRes], %[tmp1]")
+    A("lsr %[tmp2]")
+    A("adc %A[intRes], %[tmp1]")
+    A("adc %B[intRes], %[tmp1]")
    A("mul %D[longIn2], %A[longIn1]")
-    A("lsl %[tmp2]")
-    A("adc %A[intRes], r0")
+    A("add %A[intRes], r0")
    A("adc %B[intRes], r1")
    A("mul %D[longIn2], %B[longIn1]")
    A("add %B[intRes], r0")
@@ -84,16 +85,11 @@ FORCE_INLINE static uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2
  return intRes;
 }

-// intRes = intIn1 * intIn2 >> 8
+// intRes = intIn1 * intIn2 >> 16
 // uses:
-// r1, r0 for the result of mul. After the second mul, r0 holds bits 0-7 of the 24 bit result and
-// the top bit of r0 is used for rounding.
-// [tmp] to store 0.
-// [intRes] (A B) is bits 8-15 and is the returned value.
-// [charIn1] is an 8 bit parameter.
-// [intIn2] (B A) is a 16 bit parameter.
-//
-FORCE_INLINE static uint16_t MultiU8X16toH16(uint8_t charIn1, uint16_t intIn2) {
+// r26 to store 0
+// r27 to store the byte 1 of the 24 bit result
+FORCE_INLINE static uint16_t MultiU16X8toH16(uint8_t charIn1, uint16_t intIn2) {
  uint8_t tmp;
  uint16_t intRes;
  __asm__ __volatile__ (
@@ -101,8 +97,10 @@ FORCE_INLINE static uint16_t MultiU8X16toH16(uint8_t charIn1, uint16_t intIn2) {
    A("mul %[charIn1], %B[intIn2]")
    A("movw %A[intRes], r0")
    A("mul %[charIn1], %A[intIn2]")
-    A("lsl r0")
-    A("adc %A[intRes], r1")
+    A("add %A[intRes], r1")
+    A("adc %B[intRes], %[tmp]")
+    A("lsr r0")
+    A("adc %A[intRes], %[tmp]")
    A("adc %B[intRes], %[tmp]")
    A("clr r1")
      : [intRes] "=&r" (intRes),
@@ -30,7 +30,6 @@
 #include <WString.h>

 #include "../../inc/MarlinConfigPre.h"
-#include "../../core/types.h"
 #include "../../core/serial_hook.h"

 // Define constants and variables for buffering incoming serial data.  We're
@@ -53,6 +52,10 @@
 //  #error "TX_BUFFER_SIZE must be 0, a power of 2 greater than 1, and no greater than 256."
 //#endif

+// Templated type selector
+template<bool b, typename T, typename F> struct TypeSelector { typedef T type;} ;
+template<typename T, typename F> struct TypeSelector<false, T, F> { typedef F type; };
+
 // Templated structure wrapper
 template<typename S, unsigned int addr> struct StructWrapper {
  constexpr StructWrapper(int) {}
@@ -73,7 +76,7 @@ protected:
  static constexpr int HWUART_IRQ_ID = IRQ_IDS[Cfg::PORT];

  // Base size of type on buffer size
-  typedef uvalue_t(Cfg::RX_SIZE - 1) ring_buffer_pos_t;
+  typedef typename TypeSelector<(Cfg::RX_SIZE>256), uint16_t, uint8_t>::type ring_buffer_pos_t;

  struct ring_buffer_r {
    volatile ring_buffer_pos_t head, tail;
@@ -342,16 +342,16 @@ void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v
      }
      else
        pindata.pwm_duty_ticks = duty; // PWM duty count = # of 4µs ticks per full PWM cycle
-
-      return;
    }
+    else
  #endif
-
-  const int8_t cid = get_pwm_channel(pin, PWM_FREQUENCY, PWM_RESOLUTION);
-  if (cid >= 0) {
-    const uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, _BV(PWM_RESOLUTION)-1);
-    ledcWrite(cid, duty);
-  }
+    {
+      const int8_t cid = get_pwm_channel(pin, PWM_FREQUENCY, PWM_RESOLUTION);
+      if (cid >= 0) {
+        const uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, _BV(PWM_RESOLUTION)-1);
+        ledcWrite(cid, duty);
+      }
+    }
 }

 int8_t MarlinHAL::set_pwm_frequency(const pin_t pin, const uint32_t f_desired) {
@@ -360,15 +360,17 @@ int8_t MarlinHAL::set_pwm_frequency(const pin_t pin, const uint32_t f_desired) {
      pwm_pin_data[pin & 0x7F].pwm_cycle_ticks = 1000000UL / f_desired / 4; // # of 4µs ticks per full PWM cycle
      return 0;
    }
+    else
  #endif
-
-  const int8_t cid = channel_for_pin(pin);
-  if (cid >= 0) {
-    if (f_desired == ledcReadFreq(cid)) return cid; // no freq change
-    ledcDetachPin(chan_pin[cid]);
-    chan_pin[cid] = 0;              // remove old freq channel
-  }
-  return get_pwm_channel(pin, f_desired, PWM_RESOLUTION); // try for new one
+    {
+      const int8_t cid = channel_for_pin(pin);
+      if (cid >= 0) {
+        if (f_desired == ledcReadFreq(cid)) return cid; // no freq change
+        ledcDetachPin(chan_pin[cid]);
+        chan_pin[cid] = 0;              // remove old freq channel
+      }
+      return get_pwm_channel(pin, f_desired, PWM_RESOLUTION); // try for new one
+    }
 }

 // use hardware PWM if avail, if not then ISR
@@ -149,28 +149,30 @@ void stepperTask(void *parameter) {
    dma.rw_pos = 0;

    while (dma.rw_pos < DMA_SAMPLE_COUNT) {
+      // Fill with the port data post pulse_phase until the next step
+      if (nextMainISR && TERN1(LIN_ADVANCE, nextAdvanceISR))
+        i2s_push_sample();
+
+      // i2s_push_sample() is also called from Stepper::pulse_phase_isr() and Stepper::advance_isr()
+      // in a rare case where both are called, we need to double decrement the counters
+      const uint8_t push_count = 1 + (!nextMainISR && TERN0(LIN_ADVANCE, !nextAdvanceISR));
+
+      #if ENABLED(LIN_ADVANCE)
+        if (!nextAdvanceISR) {
+          Stepper::advance_isr();
+          nextAdvanceISR = Stepper::la_interval;
+        }
+        else if (nextAdvanceISR == Stepper::LA_ADV_NEVER)
+          nextAdvanceISR = Stepper::la_interval;
+      #endif
+
      if (!nextMainISR) {
        Stepper::pulse_phase_isr();
        nextMainISR = Stepper::block_phase_isr();
      }
-      #if ENABLED(LIN_ADVANCE)
-        else if (!nextAdvanceISR) {
-          Stepper::advance_isr();
-          nextAdvanceISR = Stepper::la_interval;
-        }
-      #endif
-      else
-        i2s_push_sample();

-      nextMainISR--;
-
-      #if ENABLED(LIN_ADVANCE)
-        if (nextAdvanceISR == Stepper::LA_ADV_NEVER)
-          nextAdvanceISR = Stepper::la_interval;
-
-        if (nextAdvanceISR && nextAdvanceISR != Stepper::LA_ADV_NEVER)
-          nextAdvanceISR--;
-      #endif
+      nextMainISR -= push_count;
+      TERN_(LIN_ADVANCE, nextAdvanceISR -= push_count);
    }
  }
 }
@@ -318,16 +318,8 @@ void SPIClass::dmaSend(void *buf, uint16_t length, bool minc) {
  // Enable DMA
  GPDMA_ChannelCmd(0, ENABLE);

-  /*
-   * Observed behaviour on normal data transfer completion (SKR 1.3 board / LPC1768 MCU)
-   *   GPDMA_STAT_INTTC flag is SET
-   *   GPDMA_STAT_INTERR flag is NOT SET
-   *   GPDMA_STAT_RAWINTTC flag is NOT SET
-   *   GPDMA_STAT_RAWINTERR flag is SET
-   */
-
  // Wait for data transfer
-  while (!GPDMA_IntGetStatus(GPDMA_STAT_INTTC, 0) && !GPDMA_IntGetStatus(GPDMA_STAT_INTERR, 0)) {}
+  while (!GPDMA_IntGetStatus(GPDMA_STAT_RAWINTTC, 0) && !GPDMA_IntGetStatus(GPDMA_STAT_RAWINTERR, 0)) { }

  // Clear err and int
  GPDMA_ClearIntPending (GPDMA_STATCLR_INTTC, 0);
@@ -341,43 +333,6 @@ void SPIClass::dmaSend(void *buf, uint16_t length, bool minc) {
  SSP_DMACmd(_currentSetting->spi_d, SSP_DMA_TX, DISABLE);
 }

-void SPIClass::dmaSendAsync(void *buf, uint16_t length, bool minc) {
-  //TODO: LPC dma can only write 0xFFF bytes at once.
-  GPDMA_Channel_CFG_Type GPDMACfg;
-
-  /* Configure GPDMA channel 0 -------------------------------------------------------------*/
-  /* DMA Channel 0 */
-  GPDMACfg.ChannelNum = 0;
-  // Source memory
-  GPDMACfg.SrcMemAddr = (uint32_t)buf;
-  // Destination memory - Not used
-  GPDMACfg.DstMemAddr = 0;
-  // Transfer size
-  GPDMACfg.TransferSize = length;
-  // Transfer width
-  GPDMACfg.TransferWidth = (_currentSetting->dataSize == DATA_SIZE_16BIT) ? GPDMA_WIDTH_HALFWORD : GPDMA_WIDTH_BYTE;
-  // Transfer type
-  GPDMACfg.TransferType = GPDMA_TRANSFERTYPE_M2P;
-  // Source connection - unused
-  GPDMACfg.SrcConn = 0;
-  // Destination connection
-  GPDMACfg.DstConn = (_currentSetting->spi_d == LPC_SSP0) ? GPDMA_CONN_SSP0_Tx : GPDMA_CONN_SSP1_Tx;
-
-  GPDMACfg.DMALLI = 0;
-
-  // Enable dma on SPI
-  SSP_DMACmd(_currentSetting->spi_d, SSP_DMA_TX, ENABLE);
-
-  // Only increase memory if minc is true
-  GPDMACfg.MemoryIncrease = (minc ? GPDMA_DMACCxControl_SI : 0);
-
-  // Setup channel with given parameter
-  GPDMA_Setup(&GPDMACfg);
-
-  // Enable DMA
-  GPDMA_ChannelCmd(0, ENABLE);
-}
-
 uint16_t SPIClass::read() {
  return SSP_ReceiveData(_currentSetting->spi_d);
 }
@@ -155,7 +155,6 @@ public:
  void read(uint8_t *buf, uint32_t len);

  void dmaSend(void *buf, uint16_t length, bool minc);
-  void dmaSendAsync(void *buf, uint16_t length, bool minc);

  /**
   * @brief Sets the number of the SPI peripheral to be used by
@@ -26,7 +26,7 @@

 #include "tft_spi.h"

-SPIClass TFT_SPI::SPIx(TFT_SPI_DEVICE);
+SPIClass TFT_SPI::SPIx(1);

 void TFT_SPI::Init() {
  #if PIN_EXISTS(TFT_RESET)
@@ -38,10 +38,40 @@ void TFT_SPI::Init() {
    OUT_WRITE(TFT_BACKLIGHT_PIN, HIGH);
  #endif

-  OUT_WRITE(TFT_DC_PIN, HIGH);
-  OUT_WRITE(TFT_CS_PIN, HIGH);
+  SET_OUTPUT(TFT_DC_PIN);
+  SET_OUTPUT(TFT_CS_PIN);
+  WRITE(TFT_DC_PIN, HIGH);
+  WRITE(TFT_CS_PIN, HIGH);

-  SPIx.setModule(TFT_SPI_DEVICE);
+  /**
+   * STM32F1 APB2 = 72MHz, APB1 = 36MHz, max SPI speed of this MCU if 18Mhz
+   * STM32F1 has 3 SPI ports, SPI1 in APB2, SPI2/SPI3 in APB1
+   * so the minimum prescale of SPI1 is DIV4, SPI2/SPI3 is DIV2
+   */
+  #if 0
+    #if SPI_DEVICE == 1
+     #define SPI_CLOCK_MAX SPI_CLOCK_DIV4
+    #else
+     #define SPI_CLOCK_MAX SPI_CLOCK_DIV2
+    #endif
+    uint8_t  clock;
+    uint8_t spiRate = SPI_FULL_SPEED;
+    switch (spiRate) {
+     case SPI_FULL_SPEED:    clock = SPI_CLOCK_MAX ;  break;
+     case SPI_HALF_SPEED:    clock = SPI_CLOCK_DIV4 ; break;
+     case SPI_QUARTER_SPEED: clock = SPI_CLOCK_DIV8 ; break;
+     case SPI_EIGHTH_SPEED:  clock = SPI_CLOCK_DIV16; break;
+     case SPI_SPEED_5:       clock = SPI_CLOCK_DIV32; break;
+     case SPI_SPEED_6:       clock = SPI_CLOCK_DIV64; break;
+     default:                clock = SPI_CLOCK_DIV2;  // Default from the SPI library
+    }
+  #endif
+
+  #if TFT_MISO_PIN == BOARD_SPI1_MISO_PIN
+    SPIx.setModule(1);
+  #elif TFT_MISO_PIN == BOARD_SPI2_MISO_PIN
+    SPIx.setModule(2);
+  #endif
  SPIx.setClock(SPI_CLOCK_MAX_TFT);
  SPIx.setBitOrder(MSBFIRST);
  SPIx.setDataMode(SPI_MODE0);
@@ -84,62 +114,17 @@ uint32_t TFT_SPI::ReadID(uint16_t Reg) {
  return data >> 7;
 }

-bool TFT_SPI::isBusy() {
-  #define __IS_DMA_CONFIGURED(__HANDLE__)   ((__HANDLE__)->DMACCSrcAddr != 0)
+bool TFT_SPI::isBusy() { return false; }

-  // DMA Channel 0 is hardcoded in dmaSendAsync() and dmaSend()
-  if (!__IS_DMA_CONFIGURED(LPC_GPDMACH0)) return false;
-
-  if (GPDMA_IntGetStatus(GPDMA_STAT_INTERR, 0)) {
-    // You should not be here - DMA transfer error flag is set
-    // Abort DMA transfer and release SPI
-  }
-  else {
-    // Check if DMA transfer completed flag is set
-    if (!GPDMA_IntGetStatus(GPDMA_STAT_INTTC, 0)) return true;
-    // Check if SPI TX butter is empty and SPI is idle
-    if ((SSP_GetStatus(LPC_SSPx, SSP_STAT_TXFIFO_EMPTY) == RESET) || (SSP_GetStatus(LPC_SSPx, SSP_STAT_BUSY) == SET)) return true;
-  }
-
-  Abort();
-  return false;
-}
-
-void TFT_SPI::Abort() {
-  // DMA Channel 0 is hardcoded in dmaSendAsync() and dmaSend()
-
-  // Disable DMA
-  GPDMA_ChannelCmd(0, DISABLE);
-
-  // Clear ERR and TC
-  GPDMA_ClearIntPending(GPDMA_STATCLR_INTTC, 0);
-  GPDMA_ClearIntPending(GPDMA_STATCLR_INTERR, 0);
-
-  // Disable DMA on SPI
-  SSP_DMACmd(LPC_SSPx, SSP_DMA_TX, DISABLE);
-
-  // Deconfigure DMA Channel 0
-  LPC_GPDMACH0->DMACCControl  = 0U;
-  LPC_GPDMACH0->DMACCConfig   = 0U;
-  LPC_GPDMACH0->DMACCSrcAddr  = 0U;
-  LPC_GPDMACH0->DMACCDestAddr = 0U;
-
-  DataTransferEnd();
-}
+void TFT_SPI::Abort() { DataTransferEnd(); }

 void TFT_SPI::Transmit(uint16_t Data) { SPIx.transfer(Data); }

-void TFT_SPI::Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
-  DataTransferBegin(DATASIZE_16BIT);
-  SPIx.dmaSend(Data, Count, MemoryIncrease);
-  Abort();
-}
-
 void TFT_SPI::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
  DataTransferBegin(DATASIZE_16BIT);
-  SPIx.dmaSendAsync(Data, Count, MemoryIncrease);
-
-  TERN_(TFT_SHARED_SPI, while (isBusy()));
+  WRITE(TFT_DC_PIN, HIGH);
+  SPIx.dmaSend(Data, Count, MemoryIncrease);
+  DataTransferEnd();
 }

 #endif // HAS_SPI_TFT
@@ -27,18 +27,6 @@
 #include <lpc17xx_ssp.h>
 // #include <lpc17xx_gpdma.h>

-#define IS_SPI(N) (BOARD_NR_SPI >= N && (TFT_SCK_PIN == BOARD_SPI##N##_SCK_PIN) && (TFT_MOSI_PIN == BOARD_SPI##N##_MOSI_PIN) && (TFT_MISO_PIN == BOARD_SPI##N##_MISO_PIN))
-#if IS_SPI(1)
-  #define TFT_SPI_DEVICE  1
-  #define LPC_SSPx  LPC_SSP0
-#elif IS_SPI(2)
-  #define TFT_SPI_DEVICE  2
-  #define LPC_SSPx  LPC_SSP1
-#else
-  #error "Invalid TFT SPI configuration."
-#endif
-#undef IS_SPI
-
 #ifndef LCD_READ_ID
  #define LCD_READ_ID  0x04   // Read display identification information (0xD3 on ILI9341)
 #endif
@@ -46,19 +34,17 @@
  #define LCD_READ_ID4 0xD3   // Read display identification information (0xD3 on ILI9341)
 #endif

-#define DATASIZE_8BIT     SSP_DATABIT_8
-#define DATASIZE_16BIT    SSP_DATABIT_16
-#define TFT_IO_DRIVER     TFT_SPI
-#define DMA_MAX_SIZE      0xFFF
+#define DATASIZE_8BIT    SSP_DATABIT_8
+#define DATASIZE_16BIT   SSP_DATABIT_16
+#define TFT_IO_DRIVER TFT_SPI

-#define DMA_MINC_ENABLE   1
-#define DMA_MINC_DISABLE  0
+#define DMA_MINC_ENABLE 1
+#define DMA_MINC_DISABLE 0

 class TFT_SPI {
 private:
  static uint32_t ReadID(uint16_t Reg);
  static void Transmit(uint16_t Data);
-  static void Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
  static void TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);

 public:
@@ -70,20 +56,22 @@ public:
  static void Abort();

  static void DataTransferBegin(uint16_t DataWidth = DATASIZE_16BIT);
-  static void DataTransferEnd() { WRITE(TFT_CS_PIN, HIGH); SSP_Cmd(LPC_SSPx, DISABLE); };
+  static void DataTransferEnd() { OUT_WRITE(TFT_CS_PIN, HIGH); SPIx.end(); };
  static void DataTransferAbort();

  static void WriteData(uint16_t Data) { Transmit(Data); }
-  static void WriteReg(uint16_t Reg) { WRITE(TFT_DC_PIN, LOW); Transmit(Reg); WRITE(TFT_DC_PIN, HIGH); }
+  static void WriteReg(uint16_t Reg) { OUT_WRITE(TFT_A0_PIN, LOW); Transmit(Reg); OUT_WRITE(TFT_A0_PIN, HIGH); }

-  static void WriteSequence_DMA(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_MINC_ENABLE, Data, Count); }
-  static void WriteMultiple_DMA(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_MINC_DISABLE, &Data, Count); }
-
-  static void WriteSequence(uint16_t *Data, uint16_t Count) { Transmit(DMA_MINC_ENABLE, Data, Count); }
+  static void WriteSequence(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_MINC_ENABLE, Data, Count); }
+  // static void WriteMultiple(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_MINC_DISABLE, &Data, Count); }
  static void WriteMultiple(uint16_t Color, uint32_t Count) {
+    static uint16_t Data; Data = Color;
+    //LPC dma can only write 0xFFF bytes at once.
+    #define MAX_DMA_SIZE (0xFFF - 1)
    while (Count > 0) {
-      Transmit(DMA_MINC_DISABLE, &Color, Count > DMA_MAX_SIZE ? DMA_MAX_SIZE : Count);
-      Count = Count > DMA_MAX_SIZE ? Count - DMA_MAX_SIZE : 0;
+      TransmitDMA(DMA_MINC_DISABLE, &Data, Count > MAX_DMA_SIZE ? MAX_DMA_SIZE : Count);
+      Count = Count > MAX_DMA_SIZE ? Count - MAX_DMA_SIZE : 0;
    }
+    #undef MAX_DMA_SIZE
  }
 };
@@ -44,11 +44,9 @@ uint16_t delta(uint16_t a, uint16_t b) { return a > b ? a - b : b - a; }
 #endif

 void XPT2046::Init() {
-  #if DISABLED(TOUCH_BUTTONS_HW_SPI)
-    SET_INPUT(TOUCH_MISO_PIN);
-    SET_OUTPUT(TOUCH_MOSI_PIN);
-    SET_OUTPUT(TOUCH_SCK_PIN);
-  #endif
+  SET_INPUT(TOUCH_MISO_PIN);
+  SET_OUTPUT(TOUCH_MOSI_PIN);
+  SET_OUTPUT(TOUCH_SCK_PIN);
  OUT_WRITE(TOUCH_CS_PIN, HIGH);

  #if PIN_EXISTS(TOUCH_INT)
@@ -208,8 +208,8 @@ public:
  MarlinHAL() {}

  // Watchdog
-  static void watchdog_init();
-  static void watchdog_refresh();
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});

  static void init() {}        // Called early in setup()
  static void init_board() {}  // Called less early in setup()
@@ -31,11 +31,10 @@
 #endif

 #define DATASIZE_8BIT    8
-#define DATASIZE_16BIT  16
-#define TFT_IO_DRIVER   TFT_SPI
-#define DMA_MAX_SIZE    0xFFFF
+#define DATASIZE_16BIT   16
+#define TFT_IO_DRIVER TFT_SPI

-#define DMA_MINC_ENABLE  1
+#define DMA_MINC_ENABLE 1
 #define DMA_MINC_DISABLE 0

 class TFT_SPI {
@@ -59,9 +58,7 @@ public:
  static void WriteData(uint16_t Data);
  static void WriteReg(uint16_t Reg);

-  static void WriteSequence_DMA(uint16_t *Data, uint16_t Count) { WriteSequence(Data, Count); }
-  static void WriteMultiple_DMA(uint16_t Color, uint16_t Count) { WriteMultiple(Color, Count); }
-
  static void WriteSequence(uint16_t *Data, uint16_t Count);
+  // static void WriteMultiple(uint16_t Color, uint16_t Count);
  static void WriteMultiple(uint16_t Color, uint32_t Count);
 };
@@ -168,4 +168,4 @@ uint8_t u8g_com_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
 #endif

 #endif // IS_U8GLIB_ST7920
-#endif // __PLAT_NATIVE_SIM__
+#endif // TARGET_LPC1768
@@ -1,212 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#ifdef __SAMD21__
-
-#include "../../inc/MarlinConfig.h"
-
-#include <wiring_private.h>
-
-#if USING_HW_SERIALUSB
-  DefaultSerial1 MSerialUSB(false, SerialUSB);
-#endif
-#if USING_HW_SERIAL0
-  DefaultSerial2 MSerial1(false, Serial1);
-#endif
-#if USING_HW_SERIAL1
-  DefaultSerial3 MSerial2(false, Serial2);
-#endif
-
-
-
-#define WDT_CONFIG_PER_7_Val 0x9u
-#define WDT_CONFIG_PER_Pos 0
-#define WDT_CONFIG_PER_7 (WDT_CONFIG_PER_7_Val << WDT_CONFIG_PER_Pos)
-
-#if ENABLED(USE_WATCHDOG)
-
-  #define WDT_TIMEOUT_REG TERN(WATCHDOG_DURATION_8S, WDT_CONFIG_PER_CYC8192, WDT_CONFIG_PER_CYC4096) // 4 or 8 second timeout
-
-  void MarlinHAL::watchdog_init() {
-       // Set up the generic clock (GCLK2) used to clock the watchdog timer at 1.024kHz
-    GCLK->GENDIV.reg = GCLK_GENDIV_DIV(4) |            // Divide the 32.768kHz clock source by divisor 32, where 2^(4 + 1): 32.768kHz/32=1.024kHz
-                      GCLK_GENDIV_ID(2);              // Select Generic Clock (GCLK) 2
-    while (GCLK->STATUS.bit.SYNCBUSY);                // Wait for synchronization
-
-    REG_GCLK_GENCTRL =  GCLK_GENCTRL_DIVSEL |         // Set to divide by 2^(GCLK_GENDIV_DIV(4) + 1)
-                        GCLK_GENCTRL_IDC |            // Set the duty cycle to 50/50 HIGH/LOW
-                        GCLK_GENCTRL_GENEN |          // Enable GCLK2
-                        GCLK_GENCTRL_SRC_OSCULP32K |  // Set the clock source to the ultra low power oscillator (OSCULP32K)
-                        GCLK_GENCTRL_ID(2);           // Select GCLK2
-    while (GCLK->STATUS.bit.SYNCBUSY);                // Wait for synchronization
-
-    // Feed GCLK2 to WDT (Watchdog Timer)
-    REG_GCLK_CLKCTRL =  GCLK_CLKCTRL_CLKEN |          // Enable GCLK2 to the WDT
-                        GCLK_CLKCTRL_GEN_GCLK2 |      // Select GCLK2
-                        GCLK_CLKCTRL_ID_WDT;          // Feed the GCLK2 to the WDT
-    while (GCLK->STATUS.bit.SYNCBUSY);                // Wait for synchronization
-
-    WDT->CONFIG.bit.PER = WDT_CONFIG_PER_7;                // Set the WDT reset timeout to 4 seconds
-    while (WDT->STATUS.bit.SYNCBUSY);                 // Wait for synchronization
-    REG_WDT_CTRL = WDT_CTRL_ENABLE;                   // Enable the WDT in normal mode
-    while (WDT->STATUS.bit.SYNCBUSY);                 // Wait for synchronization
-  }
-
-  // Reset watchdog. MUST be called at least every 4 seconds after the
-  // first watchdog_init or SAMD will go into emergency procedures.
-  void MarlinHAL::watchdog_refresh() {
-    WDT->CLEAR.reg = WDT_CLEAR_CLEAR_KEY;
-    while (WDT->STATUS.bit.SYNCBUSY);
-  }
-
-#endif
-
-// ------------------------
-// Types
-// ------------------------
-
-// ------------------------
-// Private Variables
-// ------------------------
-
-// ------------------------
-// Private functions
-// ------------------------
-
-void MarlinHAL::dma_init() {}
-
-// ------------------------
-// Public functions
-// ------------------------
-
-// HAL initialization task
-void MarlinHAL::init() {
-  TERN_(DMA_IS_REQUIRED, dma_init());
-  #if ENABLED(SDSUPPORT)
-    #if HAS_SD_DETECT && SD_CONNECTION_IS(ONBOARD)
-      SET_INPUT_PULLUP(SD_DETECT_PIN);
-    #endif
-    OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up
-  #endif
-}
-
-#pragma push_macro("WDT")
-#undef WDT    // Required to be able to use '.bit.WDT'. Compiler wrongly replace struct field with WDT define
-uint8_t MarlinHAL::get_reset_source() {
-
-  return 0;
-}
-#pragma pop_macro("WDT")
-
-void MarlinHAL::reboot() { NVIC_SystemReset(); }
-
-extern "C" {
-  void * _sbrk(int incr);
-  extern unsigned int __bss_end__; // end of bss section
-}
-
-// Return free memory between end of heap (or end bss) and whatever is current
-int freeMemory() {
-  int free_memory, heap_end = (int)_sbrk(0);
-  return (int)&free_memory - (heap_end ?: (int)&__bss_end__);
-}
-
-// ------------------------
-// ADC
-// ------------------------
-
-uint16_t MarlinHAL::adc_result;
-
-void MarlinHAL::adc_init() {
-  /* thanks to https://www.eevblog.com/forum/microcontrollers/samd21g18-adc-with-resrdy-interrupts-only-reads-once-or-twice/ */
-
-  ADC->CTRLA.bit.ENABLE = false;
-  while(ADC->STATUS.bit.SYNCBUSY);
-
-  // load chip corrections
-  uint32_t bias = (*((uint32_t *) ADC_FUSES_BIASCAL_ADDR) & ADC_FUSES_BIASCAL_Msk) >> ADC_FUSES_BIASCAL_Pos;
-  uint32_t linearity = (*((uint32_t *) ADC_FUSES_LINEARITY_0_ADDR) & ADC_FUSES_LINEARITY_0_Msk) >> ADC_FUSES_LINEARITY_0_Pos;
-  linearity |= ((*((uint32_t *) ADC_FUSES_LINEARITY_1_ADDR) & ADC_FUSES_LINEARITY_1_Msk) >> ADC_FUSES_LINEARITY_1_Pos) << 5;
-
-  /* Wait for bus synchronization. */
-  while (ADC->STATUS.bit.SYNCBUSY) {};
-
-  ADC->CALIB.reg = ADC_CALIB_BIAS_CAL(bias) | ADC_CALIB_LINEARITY_CAL(linearity);
-
-  /* Wait for bus synchronization. */
-  while (ADC->STATUS.bit.SYNCBUSY) {};
-
-  ADC->CTRLA.bit.SWRST = true;
-  while(ADC->STATUS.bit.SYNCBUSY);
-
-  ADC->REFCTRL.reg = ADC_REFCTRL_REFSEL_INTVCC1;
-  ADC->AVGCTRL.reg = ADC_AVGCTRL_SAMPLENUM_32| ADC_AVGCTRL_ADJRES(4);;
-
-
-  ADC->CTRLB.reg = ADC_CTRLB_PRESCALER_DIV128 |
-                 ADC_CTRLB_RESSEL_16BIT |
-                 ADC_CTRLB_FREERUN;
-  while(ADC->STATUS.bit.SYNCBUSY);
-
-  ADC->SAMPCTRL.bit.SAMPLEN = 0x00;
-  while(ADC->STATUS.bit.SYNCBUSY);
-
-  ADC->INPUTCTRL.reg =  ADC_INPUTCTRL_INPUTSCAN(HAL_ADC_AIN_LEN) // scan  (INPUTSCAN + NUM_EXTUDERS - 1) pins
-  | ADC_INPUTCTRL_GAIN_DIV2  |ADC_INPUTCTRL_MUXNEG_GND| HAL_ADC_AIN_START ;  /* set to first AIN */
-
-  while(ADC->STATUS.bit.SYNCBUSY);
-
-  ADC->INTENSET.reg |= ADC_INTENSET_RESRDY; // enable Result Ready ADC interrupts
-  while (ADC->STATUS.bit.SYNCBUSY);
-
-  NVIC_EnableIRQ(ADC_IRQn); // enable ADC interrupts
-
-  NVIC_SetPriority(ADC_IRQn, 3);
-
-  ADC->CTRLA.bit.ENABLE = true;
-}
-
-volatile uint32_t adc_results[HAL_ADC_AIN_NUM_SENSORS];
-
-void ADC_Handler() {
-  while(ADC->STATUS.bit.SYNCBUSY == 1);
-  int pos = ADC->INPUTCTRL.bit.INPUTOFFSET;
-
-  adc_results[pos] = ADC->RESULT.reg; /* Read the value. */
-  ADC->INTFLAG.reg = ADC_INTENSET_RESRDY; /* Clear the data ready flag. */
-}
-
-void MarlinHAL::adc_start(const pin_t pin) {
-  /* due to the way INPUTOFFSET works, the last sensor is the first position in the array
-    and we want the ADC_handler interrupt to be as simple possible, so we do the calculation here.
-  */
-  unsigned int pos = PIN_TO_INPUTCTRL(pin) - HAL_ADC_AIN_START + 1;
-  if (pos == HAL_ADC_AIN_NUM_SENSORS) pos = 0;
-  adc_result = adc_results[pos]; // 16-bit resolution
-  //adc_result = 0xFFFF;
-}
-
-#endif // __SAMD21__
@@ -1,223 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-#define CPU_32_BIT
-
-#include "../shared/Marduino.h"
-#include "../shared/math_32bit.h"
-#include "../shared/HAL_SPI.h"
-#include "fastio.h"
-
-// ------------------------
-// Serial ports
-// ------------------------
-#include "../../core/serial_hook.h"
-typedef ForwardSerial1Class< decltype(SerialUSB) > DefaultSerial1;
-extern DefaultSerial1 MSerialUSB;
-
-// Serial ports
-typedef ForwardSerial1Class< decltype(Serial1) > DefaultSerial2;
-typedef ForwardSerial1Class< decltype(Serial2) > DefaultSerial3;
-
-extern DefaultSerial2 MSerial0;
-extern DefaultSerial3 MSerial1;
-
-
-#define __MSERIAL(X) MSerial##X
-#define _MSERIAL(X) __MSERIAL(X)
-#define MSERIAL(X) _MSERIAL(INCREMENT(X))
-
-#if WITHIN(SERIAL_PORT, 0, 1)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
-#elif SERIAL_PORT == -1
-  #define MYSERIAL1 MSerialUSB
-#else
-  #error "SERIAL_PORT must be -1 (Native USB only)."
-#endif
-
-#ifdef SERIAL_PORT_2
-  #if WITHIN(SERIAL_PORT_2, 0, 1)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT)
-  #elif SERIAL_PORT_2 == -1
-    #define MYSERIAL2 MSerialUSB
-  #else
-    #error "SERIAL_PORT_2 must be -1 (Native USB only)."
-  #endif
-#endif
-
-#ifdef MMU2_SERIAL_PORT
-  #if WITHIN(MMU2_SERIAL_PORT, 0, 1)
-    #define MMU2_SERIAL MSERIAL(SERIAL_PORT)
-  #elif MMU2_SERIAL_PORT == -1
-    #define MMU2_SERIAL MSerialUSB
-  #else
-    #error "MMU2_SERIAL_PORT must be -1 (Native USB only)."
-  #endif
-#endif
-
-#ifdef LCD_SERIAL_PORT
-  #if WITHIN(LCD_SERIAL_PORT, 0, 1)
-    #define LCD_SERIAL MSERIAL(SERIAL_PORT)
-  #elif LCD_SERIAL_PORT == -1
-    #define LCD_SERIAL MSerialUSB
-  #else
-    #error "LCD_SERIAL_PORT must be -1 (Native USB only)."
-  #endif
-#endif
-
-typedef int8_t pin_t;
-
-#define SHARED_SERVOS HAS_SERVOS  // Use shared/servos.cpp
-
-class Servo;
-typedef Servo hal_servo_t;
-
-//
-// Interrupts
-//
-#define CRITICAL_SECTION_START()  const bool irqon = !__get_PRIMASK(); __disable_irq()
-#define CRITICAL_SECTION_END()    if (irqon) __enable_irq()
-
-#define cli() __disable_irq() // Disable interrupts
-#define sei() __enable_irq()  // Enable interrupts
-
-//
-// ADC
-//
-
-#define HAL_ADC_FILTERED     1     // Disable Marlin's oversampling. The HAL filters ADC values.
-#define HAL_ADC_VREF         3.3
-#define HAL_ADC_RESOLUTION   12
-#define HAL_ADC_AIN_START ADC_INPUTCTRL_MUXPOS_PIN3
-#define HAL_ADC_AIN_NUM_SENSORS 3
-#define HAL_ADC_AIN_LEN HAL_ADC_AIN_NUM_SENSORS-1
-
-//
-// Pin Mapping for M42, M43, M226
-//
-#define GET_PIN_MAP_PIN(index) index
-#define GET_PIN_MAP_INDEX(pin) pin
-#define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
-
-//
-// Tone
-//
-void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration=0);
-void noTone(const pin_t _pin);
-
-// ------------------------
-// Class Utilities
-// ------------------------
-
-#pragma GCC diagnostic push
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);
-
-extern "C" int freeMemory();
-
-#ifdef __cplusplus
-  }
-#endif
-
-#pragma GCC diagnostic pop
-
-// ------------------------
-// MarlinHAL Class
-// ------------------------
-
-class MarlinHAL {
-public:
-
-  // Earliest possible init, before setup()
-  MarlinHAL() {}
-
-  // Watchdog
-  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
-  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
-
-  static void init();          // Called early in setup()
-  static void init_board() {}  // Called less early in setup()
-  static void reboot();        // Restart the firmware from 0x0
-
-  // Interrupts
-  static bool isr_state() { return !__get_PRIMASK(); }
-  static void isr_on()  { sei(); }
-  static void isr_off() { cli(); }
-
-  static void delay_ms(const int ms) { delay(ms); }
-
-  // Tasks, called from idle()
-  static void idletask() {}
-
-  // Reset
-  static uint8_t get_reset_source();
-  static void clear_reset_source() {}
-
-  // Free SRAM
-  static int freeMemory() { return ::freeMemory(); }
-
-  //
-  // ADC Methods
-  //
-
-  static uint16_t adc_result;
-
-  // Called by Temperature::init once at startup
-  static void adc_init();
-
-  // Called by Temperature::init for each sensor at startup
-  static void adc_enable(const uint8_t ch) {}
-
-  // Begin ADC sampling on the given pin. Called from Temperature::isr!
-  static void adc_start(const pin_t pin);
-
-  // Is the ADC ready for reading?
-  static bool adc_ready() { return true; }
-
-  // The current value of the ADC register
-  static uint16_t adc_value() { return adc_result; }
-
-  /**
-   * Set the PWM duty cycle for the pin to the given value.
-   * No option to invert the duty cycle [default = false]
-   * No option to change the scale of the provided value to enable finer PWM duty control [default = 255]
-   */
-  static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t=255, const bool=false) {
-    analogWrite(pin, v);
-  }
-
-private:
-  static void dma_init();
-};
@@ -1,148 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-/**
- * Hardware and software SPI implementations are included in this file.
- *
- * Control of the slave select pin(s) is handled by the calling routines and
- * SAMD21 let hardware SPI handling to remove SS from its logic.
- */
-
-#ifdef __SAMD21__
-
-// --------------------------------------------------------------------------
-// Includes
-// --------------------------------------------------------------------------
-
-#include "../../inc/MarlinConfig.h"
-#include <SPI.h>
-
-// --------------------------------------------------------------------------
-// Public functions
-// --------------------------------------------------------------------------
-
-#if EITHER(SOFTWARE_SPI, FORCE_SOFT_SPI)
-
-  // ------------------------
-  // Software SPI
-  // ------------------------
-  #error "Software SPI not supported for SAMD21. Use Hardware SPI."
-
-#else // !SOFTWARE_SPI
-
-  static SPISettings spiConfig;
-
-  // ------------------------
-  // Hardware SPI
-  // ------------------------
-  void spiBegin() {
-    spiInit(SPI_HALF_SPEED);
-  }
-
-  void spiInit(uint8_t spiRate) {
-    // Use datarates Marlin uses
-    uint32_t clock;
-    switch (spiRate) {
-      case SPI_FULL_SPEED:      clock = 8000000; break;
-      case SPI_HALF_SPEED:      clock = 4000000; break;
-      case SPI_QUARTER_SPEED:   clock = 2000000; break;
-      case SPI_EIGHTH_SPEED:    clock = 1000000; break;
-      case SPI_SIXTEENTH_SPEED: clock =  500000; break;
-      case SPI_SPEED_5:         clock =  250000; break;
-      case SPI_SPEED_6:         clock =  125000; break;
-      default:                  clock = 4000000; break; // Default from the SPI library
-    }
-    spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0);
-    SPI.begin();
-  }
-
-  /**
-   * @brief  Receives a single byte from the SPI port.
-   *
-   * @return Byte received
-   *
-   * @details
-   */
-  uint8_t spiRec() {
-    SPI.beginTransaction(spiConfig);
-    uint8_t returnByte = SPI.transfer(0xFF);
-    SPI.endTransaction();
-    return returnByte;
-  }
-
-  /**
-   * @brief  Receives a number of bytes from the SPI port to a buffer
-   *
-   * @param  buf   Pointer to starting address of buffer to write to.
-   * @param  nbyte Number of bytes to receive.
-   * @return Nothing
-   */
-  void spiRead(uint8_t *buf, uint16_t nbyte) {
-    if (nbyte == 0) return;
-    memset(buf, 0xFF, nbyte);
-
-    SPI.beginTransaction(spiConfig);
-    SPI.transfer(buf, nbyte);
-    SPI.endTransaction();
-
-  }
-
-  /**
-   * @brief  Sends a single byte on SPI port
-   *
-   * @param  b Byte to send
-   *
-   * @details
-   */
-  void spiSend(uint8_t b) {
-    SPI.beginTransaction(spiConfig);
-    SPI.transfer(b);
-    SPI.endTransaction();
-  }
-
-  /**
-   * @brief  Write token and then write from 512 byte buffer to SPI (for SD card)
-   *
-   * @param  buf   Pointer with buffer start address
-   * @return Nothing
-   *
-   * @details Uses DMA
-   */
-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
-    SPI.beginTransaction(spiConfig);
-    SPI.transfer(token);
-    SPI.transfer((uint8_t*)buf, 512);
-    SPI.endTransaction();
-  }
-
-  void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) {
-    spiConfig = SPISettings(spiClock, (BitOrder)bitOrder, dataMode);
-    SPI.beginTransaction(spiConfig);
-  }
-#endif // !SOFTWARE_SPI
-
-#endif // __SAMD21__
@@ -1,31 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#pragma once
-
-#include <SPI.h>
-
-using MarlinSPI = SPIClass;
@@ -1,82 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(QSPI_EEPROM)
-
-#include "QSPIFlash.h"
-
-#define INVALID_ADDR    0xFFFFFFFF
-#define SECTOR_OF(a)    (a & ~(SFLASH_SECTOR_SIZE - 1))
-#define OFFSET_OF(a)    (a & (SFLASH_SECTOR_SIZE - 1))
-
-Adafruit_SPIFlashBase * QSPIFlash::_flashBase = nullptr;
-uint8_t QSPIFlash::_buf[SFLASH_SECTOR_SIZE];
-uint32_t QSPIFlash::_addr = INVALID_ADDR;
-
-void QSPIFlash::begin() {
-  if (_flashBase) return;
-
-  _flashBase = new Adafruit_SPIFlashBase(new Adafruit_FlashTransport_QSPI());
-  _flashBase->begin(nullptr);
-}
-
-size_t QSPIFlash::size() {
-  return _flashBase->size();
-}
-
-uint8_t QSPIFlash::readByte(const uint32_t address) {
-  if (SECTOR_OF(address) == _addr) return _buf[OFFSET_OF(address)];
-
-  return _flashBase->read8(address);
-}
-
-void QSPIFlash::writeByte(const uint32_t address, const uint8_t value) {
-  uint32_t const sector_addr = SECTOR_OF(address);
-
-  // Page changes, flush old and update new cache
-  if (sector_addr != _addr) {
-    flush();
-    _addr = sector_addr;
-
-    // read a whole page from flash
-    _flashBase->readBuffer(sector_addr, _buf, SFLASH_SECTOR_SIZE);
-  }
-
-  _buf[OFFSET_OF(address)] = value;
-}
-
-void QSPIFlash::flush() {
-  if (_addr == INVALID_ADDR) return;
-
-  _flashBase->eraseSector(_addr / SFLASH_SECTOR_SIZE);
-  _flashBase->writeBuffer(_addr, _buf, SFLASH_SECTOR_SIZE);
-
-  _addr = INVALID_ADDR;
-}
-
-#endif // QSPI_EEPROM
@@ -1,49 +0,0 @@
-/**
- * @file QSPIFlash.h
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2019 Ha Thach and Dean Miller for Adafruit Industries LLC
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- * Derived from Adafruit_SPIFlash class with no SdFat references
- */
-#pragma once
-
-#include <Adafruit_SPIFlashBase.h>
-
-// This class extends Adafruit_SPIFlashBase by adding caching support.
-//
-// This class will use 4096 Bytes of RAM as a block cache.
-class QSPIFlash {
-  public:
-    static void begin();
-    static size_t size();
-    static uint8_t readByte(const uint32_t address);
-    static void writeByte(const uint32_t address, const uint8_t v);
-    static void flush();
-
-  private:
-    static Adafruit_SPIFlashBase * _flashBase;
-    static uint8_t _buf[SFLASH_SECTOR_SIZE];
-    static uint32_t _addr;
-};
-
-extern QSPIFlash qspi;
@@ -1,66 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-#define SYNC(sc)    while (sc) {  \
-                      asm("");    \
-                    }
-
-// Get SAMD port/pin from specified arduino pin
-#define GET_SAMD_PORT(P)    _GET_SAMD_PORT(PIN_TO_SAMD_PIN(P))
-#define GET_SAMD_PIN(P)     _GET_SAMD_PIN(PIN_TO_SAMD_PIN(P))
-
-// Get external interrupt line associated to specified arduino pin
-#define PIN_TO_EILINE(P)    _SAMDPORTPIN_TO_EILINE(GET_SAMD_PORT(P), GET_SAMD_PIN(P))
-
-// Get adc/ain associated to specified arduino pin
-#define PIN_TO_ADC(P)       (ANAPIN_TO_ADCAIN(P) >> 8)
-
-// Private defines
-#define PIN_TO_SAMD_PIN(P)    DIO##P##_PIN
-
-#define _GET_SAMD_PORT(P)     ((P) >> 5)
-#define _GET_SAMD_PIN(P)      ((P) & 0x1F)
-
-// Get external interrupt line
-#define _SAMDPORTPIN_TO_EILINE(P,B)   ((P == 0 && WITHIN(B, 0, 31) && B != 26 && B != 28 && B != 29) ? (B) & 0xF    \
-                                       : (P == 1 && (WITHIN(B, 0, 25) || WITHIN(B, 30, 31))) ? (B) & 0xF                      \
-                                       : (P == 1 && WITHIN(B, 26, 29)) ? 12 + (B) - 26                                        \
-                                       : (P == 2 && (WITHIN(B, 0, 6) || WITHIN(B, 10, 31)) && B != 29) ? (B) & 0xF            \
-                                       : (P == 2 && B == 7) ? 9                                                               \
-                                       : (P == 3 && WITHIN(B, 0, 1)) ? (B)                                                    \
-                                       : (P == 3 && WITHIN(B, 8, 12)) ? 3 + (B) - 8                                           \
-                                       : (P == 3 && WITHIN(B, 20, 21)) ? 10 + (B) - 20                                        \
-                                       : -1)
-
-
-
-#define A2_AIN 3
-#define A3_AIN 4
-#define A4_AIN 5
-#define PIN_TO_AIN(P)    A##P##_AIN
-#define AIN_TO_RESULT(P) ( (P - HAL_ADC_AIN_START == HAL_ADC_AIN_NUM_SENSORS-1) ? 0 :  (P - HAL_ADC_AIN_START + 1) )
@@ -1,220 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-/**
- * This comes from Arduino library which at the moment is buggy and uncompilable
- */
-
-#ifdef __SAMD21__
-
-#include "../../inc/MarlinConfig.h"
-
-#if HAS_SERVOS
-
-#include "../shared/servo.h"
-#include "../shared/servo_private.h"
-#include "SAMD21.h"
-
-#define __TC_GCLK_ID(t)         TC##t##_GCLK_ID
-#define _TC_GCLK_ID(t)          __TC_GCLK_ID(t)
-#define TC_GCLK_ID              _TC_GCLK_ID(SERVO_TC)
-
-#define _TC_PRESCALER(d)        TC_CTRLA_PRESCALER_DIV##d##_Val
-#define TC_PRESCALER(d)         _TC_PRESCALER(d)
-
-#define __SERVO_IRQn(t)         TC##t##_IRQn
-#define _SERVO_IRQn(t)          __SERVO_IRQn(t)
-#define SERVO_IRQn              _SERVO_IRQn(SERVO_TC)
-
-#define HAL_SERVO_TIMER_ISR()   TC_HANDLER(SERVO_TC)
-
-#define TIMER_TCCHANNEL(t)      ((t) & 1)
-#define TC_COUNTER_START_VAL    0xFFFF
-
-
-static volatile int8_t currentServoIndex[_Nbr_16timers];    // index for the servo being pulsed for each timer (or -1 if refresh interval)
-
-FORCE_INLINE static uint16_t getTimerCount() {
-  Tcc * const tc = timer_config[SERVO_TC].pTcc;
-
-  tc->CTRLBSET.reg = TCC_CTRLBCLR_CMD_READSYNC;
-  SYNC(tc->STATUS.reg & TC_STATUS_SYNCBUSY);
-
-  return tc->COUNT.bit.COUNT;
-}
-
-// ----------------------------
-// Interrupt handler for the TC
-// ----------------------------
-HAL_SERVO_TIMER_ISR() {
-  Tcc * const tc = timer_config[SERVO_TC].pTcc;
-  const timer16_Sequence_t timer =
-    #ifndef _useTimer1
-      _timer2
-    #elif !defined(_useTimer2)
-      _timer1
-    #else
-      (tc->INTFLAG.reg & tc->INTENSET.reg & TC_INTFLAG_MC0) ? _timer1 : _timer2
-    #endif
-  ;
-  const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
-
-  int8_t cho = currentServoIndex[timer];                // Handle the prior servo first
-  if (cho < 0) {                                        // Servo -1 indicates the refresh interval completed...
-    #if defined(_useTimer1) && defined(_useTimer2)
-      if (currentServoIndex[timer ^ 1] >= 0) {
-        // Wait for both channels
-        // Clear the interrupt
-        tc->INTFLAG.reg = (tcChannel == 0) ? TC_INTFLAG_MC0 : TC_INTFLAG_MC1;
-        return;
-      }
-    #endif
-    tc->COUNT.reg = TC_COUNTER_START_VAL;       // ...so reset the timer
-    SYNC(tc->STATUS.reg & TC_STATUS_SYNCBUSY);
-  }
-  else if (SERVO_INDEX(timer, cho) < ServoCount)        // prior channel handled?
-    digitalWrite(SERVO(timer, cho).Pin.nbr, LOW);       // pulse the prior channel LOW
-
-  currentServoIndex[timer] = ++cho;                     // go to the next channel (or 0)
-  if (cho < SERVOS_PER_TIMER && SERVO_INDEX(timer, cho) < ServoCount) {
-    if (SERVO(timer, cho).Pin.isActive)                 // activated?
-      digitalWrite(SERVO(timer, cho).Pin.nbr, HIGH);    // yes: pulse HIGH
-
-    tc->CC[tcChannel].reg = getTimerCount() - (uint16_t)SERVO(timer, cho).ticks;
-  }
-  else {
-    // finished all channels so wait for the refresh period to expire before starting over
-    currentServoIndex[timer] = -1;                                          // reset the timer COUNT.reg on the next call
-    const uint16_t cval = getTimerCount() - 256 / (SERVO_TIMER_PRESCALER),  // allow 256 cycles to ensure the next CV not missed
-                   ival = (TC_COUNTER_START_VAL) - (uint16_t)usToTicks(REFRESH_INTERVAL); // at least REFRESH_INTERVAL has elapsed
-    tc->CC[tcChannel].reg = min(cval, ival);
-  }
-  if (tcChannel == 0) {
-    SYNC(tc->SYNCBUSY.bit.CC0);
-    tc->INTFLAG.reg = TC_INTFLAG_MC0; // Clear the interrupt
-  }
-  else {
-    SYNC(tc->SYNCBUSY.bit.CC1);
-    tc->INTFLAG.reg = TC_INTFLAG_MC1; // Clear the interrupt
-  }
-}
-
-void initISR(const timer16_Sequence_t timer) {
-  Tcc * const tc = timer_config[SERVO_TC].pTcc;
-  const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
-
-  static bool initialized = false;  // Servo TC has been initialized
-  if (!initialized) {
-    NVIC_DisableIRQ(SERVO_IRQn);
-
-    // Disable the timer
-    tc->CTRLA.bit.ENABLE = false;
-    SYNC(tc->STATUS.reg & TC_STATUS_SYNCBUSY);
-
-    // Select GCLK0 as timer/counter input clock source
-    GCLK->CLKCTRL.reg =(GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_ID(TCC0_GCLK_ID));
-    SYNC (GCLK->STATUS.bit.SYNCBUSY);
-
-    // Reset the timer
-    tc->CTRLA.bit.SWRST = true;
-    SYNC(tc->CTRLA.bit.SWRST);
-
-    // Set timer counter mode to 16 bits
-    tc->CTRLA.reg = TC_CTRLA_MODE_COUNT16;
-
-    // Set timer counter mode as normal PWM
-    tc->WAVE.bit.WAVEGEN = TCC_WAVE_WAVEGEN_NPWM_Val;
-
-    // Set the prescaler factor
-    tc->CTRLA.bit.PRESCALER = TC_PRESCALER(SERVO_TIMER_PRESCALER);
-
-    // Count down
-    tc->CTRLBSET.reg = TCC_CTRLBCLR_DIR;
-    SYNC(tc->SYNCBUSY.bit.CTRLB);
-
-    // Reset all servo indexes
-    memset((void *)currentServoIndex, 0xFF, sizeof(currentServoIndex));
-
-    // Configure interrupt request
-    NVIC_ClearPendingIRQ(SERVO_IRQn);
-    NVIC_SetPriority(SERVO_IRQn, 5);
-    NVIC_EnableIRQ(SERVO_IRQn);
-
-    initialized = true;
-  }
-
-  if (!tc->CTRLA.bit.ENABLE) {
-    // Reset the timer counter
-    tc->COUNT.reg = TC_COUNTER_START_VAL;
-    SYNC(tc->STATUS.reg & TC_STATUS_SYNCBUSY);
-
-    // Enable the timer and start it
-    tc->CTRLA.bit.ENABLE = true;
-    SYNC(tc->STATUS.reg & TC_STATUS_SYNCBUSY);
-  }
-  // First interrupt request after 1 ms
-  tc->CC[tcChannel].reg = getTimerCount() - (uint16_t)usToTicks(1000UL);
-
-  if (tcChannel == 0 ) {
-    SYNC(tc->SYNCBUSY.bit.CC0);
-
-    // Clear pending match interrupt
-    tc->INTFLAG.reg = TC_INTENSET_MC0;
-    // Enable the match channel interrupt request
-    tc->INTENSET.reg = TC_INTENSET_MC0;
-  }
-  else {
-    SYNC(tc->SYNCBUSY.bit.CC1);
-
-    // Clear pending match interrupt
-    tc->INTFLAG.reg = TC_INTENSET_MC1;
-    // Enable the match channel interrupt request
-    tc->INTENSET.reg = TC_INTENSET_MC1;
-  }
-}
-
-void finISR(const timer16_Sequence_t timer_index) {
-  Tcc * const tc = timer_config[SERVO_TC].pTcc;
-  const uint8_t tcChannel = TIMER_TCCHANNEL(timer_index);
-
-  // Disable the match channel interrupt request
-  tc->INTENCLR.reg = (tcChannel == 0) ? TC_INTENCLR_MC0 : TC_INTENCLR_MC1;
-
-  if (true
-    #if defined(_useTimer1) && defined(_useTimer2)
-      && (tc->INTENCLR.reg & (TC_INTENCLR_MC0|TC_INTENCLR_MC1)) == 0
-    #endif
-  ) {
-    // Disable the timer if not used
-    tc->CTRLA.bit.ENABLE = false;
-    SYNC(tc->STATUS.reg & TC_STATUS_SYNCBUSY);
-  }
-}
-
-#endif // HAS_SERVOS
-
-#endif // __SAMD21__
@@ -1,45 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-#define _useTimer1
-#define _useTimer2
-
-#define TRIM_DURATION           5   // compensation ticks to trim adjust for digitalWrite delays
-#define SERVO_TIMER_PRESCALER   64  // timer prescaler factor to 64 (avoid overflowing 16-bit clock counter, at 120MHz this is 1831 ticks per millisecond
-
-#define SERVO_TC                3
-
-typedef enum {
-  #ifdef _useTimer1
-    _timer1,
-  #endif
-  #ifdef _useTimer2
-    _timer2,
-  #endif
-  _Nbr_16timers
-} timer16_Sequence_t;
@@ -1,141 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#ifdef __SAMD21__
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(FLASH_EEPROM_EMULATION)
-
-#define TOTAL_FLASH_SIZE (MARLIN_EEPROM_SIZE+255)/256*256
-
-/* reserve flash memory */
-static const uint8_t flashdata[TOTAL_FLASH_SIZE]  __attribute__((__aligned__(256))) { }; \
-
-#include "../shared/eeprom_api.h"
-
-size_t PersistentStore::capacity() {
-  return MARLIN_EEPROM_SIZE;
- /* const uint8_t psz = NVMCTRL->SEESTAT.bit.PSZ,
-                sblk = NVMCTRL->SEESTAT.bit.SBLK;
-
-  return   (!psz && !sblk)         ? 0
-         : (psz <= 2)              ? (0x200 << psz)
-         : (sblk == 1 || psz == 3) ?  4096
-         : (sblk == 2 || psz == 4) ?  8192
-         : (sblk <= 4 || psz == 5) ? 16384
-         : (sblk >= 9 && psz == 7) ? 65536
-                                   : 32768;*/
-}
-
-uint32_t PAGE_SIZE;
-uint32_t ROW_SIZE;
-bool hasWritten = false;
-uint8_t * buffer;
-
-void _erase(const volatile void *flash_ptr) {
-  NVMCTRL->ADDR.reg = ((uint32_t)flash_ptr) / 2;
-  NVMCTRL->CTRLA.reg = NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_ER;
-  while (!NVMCTRL->INTFLAG.bit.READY) { }
-
-}
-
-void erase(const volatile void *flash_ptr, uint32_t size) {
-  const uint8_t *ptr = (const uint8_t *)flash_ptr;
-  while (size > ROW_SIZE) {
-    _erase(ptr);
-    ptr += ROW_SIZE;
-    size -= ROW_SIZE;
-  }
-  _erase(ptr);
-}
-
-bool PersistentStore::access_start() {
-  /* clear page buffer*/
-  NVMCTRL->CTRLA.reg = NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_PBC;
-  while (NVMCTRL->INTFLAG.bit.READY == 0) { }
-
-  PAGE_SIZE =  pow(2,3 + NVMCTRL->PARAM.bit.PSZ);
-  ROW_SIZE= PAGE_SIZE * 4;
-  /*NVMCTRL->SEECFG.reg = NVMCTRL_SEECFG_WMODE_BUFFERED;  // Buffered mode and segment reallocation active
-  if (NVMCTRL->SEESTAT.bit.RLOCK)
-    NVMCTRL_CMD(NVMCTRL_CTRLB_CMD_USEE);  */  // Unlock E2P data write access
-  //   erase(&flashdata[0], TOTAL_FLASH_SIZE);
-  return true;
-}
-
-bool PersistentStore::access_finish() {
-  if (hasWritten) {
-    erase(&flashdata[0], TOTAL_FLASH_SIZE);
-
-    NVMCTRL->CTRLA.reg = NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_PBC;
-    while (NVMCTRL->INTFLAG.bit.READY == 0) { }
-
-     NVMCTRL->CTRLB.bit.MANW = 0;
-
-    volatile uint32_t *dst_addr =  (volatile uint32_t *) &flashdata;
-
-    uint32_t *pointer = (uint32_t *) buffer;
-    for (uint32_t i = 0; i < TOTAL_FLASH_SIZE; i+=4) {
-
-      *dst_addr = (uint32_t) *pointer;
-      pointer++;
-      dst_addr ++;
-    }
-
-    // Execute "WP" Write Page
-    NVMCTRL->CTRLA.reg = NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_WP;
-    while (NVMCTRL->INTFLAG.bit.READY == 0) { }
-
-    free(buffer);
-    hasWritten = false;
-  }
-  return true;
-}
-
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  if (!hasWritten) {
-    // init temp buffer
-    buffer = (uint8_t *) malloc(MARLIN_EEPROM_SIZE);
-    hasWritten=true;
-  }
-
-  memcpy(buffer+pos,value,size);
-  pos += size;
-  return false;
-}
-
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  volatile uint8_t *dst_addr =  (volatile uint8_t *) &flashdata;
-  dst_addr += pos;
-
-  memcpy(value,(const void *) dst_addr,size);
-  pos += size;
-  return false;
-}
-
-#endif // FLASH_EEPROM_EMULATION
-#endif // __SAMD21__
@@ -1,79 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#ifdef __SAMD21__
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(QSPI_EEPROM)
-
-#error "QSPI_EEPROM emulation Not implemented on SAMD21"
-
-#include "../shared/eeprom_api.h"
-
-#include "QSPIFlash.h"
-
-static bool initialized;
-
-size_t PersistentStore::capacity() { return qspi.size(); }
-
-bool PersistentStore::access_start() {
-  if (!initialized) {
-    qspi.begin();
-    initialized = true;
-  }
-  return true;
-}
-
-bool PersistentStore::access_finish() {
-  qspi.flush();
-  return true;
-}
-
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  while (size--) {
-    const uint8_t v = *value;
-    qspi.writeByte(pos, v);
-    crc16(crc, &v, 1);
-    pos++;
-    value++;
-  }
-  return false;
-}
-
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  while (size--) {
-    uint8_t c = qspi.readByte(pos);
-    if (writing) *value = c;
-    crc16(crc, &c, 1);
-    pos++;
-    value++;
-  }
-  return false;
-}
-
-#endif // QSPI_EEPROM
-#endif // __SAMD21__
@@ -1,82 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#ifdef __SAMD21__
-
-#include "../../inc/MarlinConfig.h"
-
-#if USE_WIRED_EEPROM
-
-#error "USE_WIRED_EEPROM emulation Not implemented on SAMD21"
-/**
- * PersistentStore for Arduino-style EEPROM interface
- * with simple implementations supplied by Marlin.
- */
-
-#include "../shared/eeprom_if.h"
-#include "../shared/eeprom_api.h"
-
-#ifndef MARLIN_EEPROM_SIZE
-  #error "MARLIN_EEPROM_SIZE is required for I2C / SPI EEPROM."
-#endif
-size_t PersistentStore::capacity()    { return MARLIN_EEPROM_SIZE; }
-
-bool PersistentStore::access_start()  { eeprom_init(); return true; }
-bool PersistentStore::access_finish() { return true; }
-
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
-  while (size--) {
-    const uint8_t v = *value;
-    uint8_t * const p = (uint8_t * const)pos;
-    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
-      eeprom_write_byte(p, v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
-      if (eeprom_read_byte(p) != v) {
-        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
-        return true;
-      }
-    }
-    crc16(crc, &v, 1);
-    pos++;
-    value++;
-  }
-  return false;
-}
-
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  while (size--) {
-    uint8_t c = eeprom_read_byte((uint8_t*)pos);
-    if (writing) *value = c;
-    crc16(crc, &c, 1);
-    pos++;
-    value++;
-  }
-  return false;
-}
-
-#endif // USE_WIRED_EEPROM
-#endif // __SAMD21__
@@ -1,253 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-/**
- * Endstop interrupts for ATMEL SAMD21 based targets.
- *
- * On SAMD21, all pins support external interrupt capability.
- * Any pin can be used for external interrupts, but there are some restrictions.
- * At most 16 different external interrupts can be used at one time.
- * Further, you can’t just pick any 16 pins to use. This is because every pin on the SAMD21
- * connects to what is called an EXTINT line, and only one pin per EXTINT line can be used for external
- * interrupts at a time
- */
-
-/**
- * Endstop Interrupts
- *
- * Without endstop interrupts the endstop pins must be polled continually in
- * the temperature-ISR via endstops.update(), most of the time finding no change.
- * With this feature endstops.update() is called only when we know that at
- * least one endstop has changed state, saving valuable CPU cycles.
- *
- * This feature only works when all used endstop pins can generate an 'external interrupt'.
- *
- * Test whether pins issue interrupts on your board by flashing 'pin_interrupt_test.ino'.
- * (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino)
- */
-
-#include "../../module/endstops.h"
-
-#define MATCH_EILINE(P1,P2) (P1 != P2 && PIN_TO_EILINE(P1) == PIN_TO_EILINE(P2))
-#define MATCH_X_MAX_EILINE(P)   TERN0(HAS_X_MAX,  DEFER4(MATCH_EILINE)(P, X_MAX_PIN))
-#define MATCH_X_MIN_EILINE(P)   TERN0(HAS_X_MIN,  DEFER4(MATCH_EILINE)(P, X_MIN_PIN))
-#define MATCH_Y_MAX_EILINE(P)   TERN0(HAS_Y_MAX,  DEFER4(MATCH_EILINE)(P, Y_MAX_PIN))
-#define MATCH_Y_MIN_EILINE(P)   TERN0(HAS_Y_MIN,  DEFER4(MATCH_EILINE)(P, Y_MIN_PIN))
-#define MATCH_Z_MAX_EILINE(P)   TERN0(HAS_Z_MAX,  DEFER4(MATCH_EILINE)(P, Z_MAX_PIN))
-#define MATCH_Z_MIN_EILINE(P)   TERN0(HAS_Z_MIN,  DEFER4(MATCH_EILINE)(P, Z_MIN_PIN))
-#define MATCH_I_MAX_EILINE(P)   TERN0(HAS_I_MAX,  DEFER4(MATCH_EILINE)(P, I_MAX_PIN))
-#define MATCH_I_MIN_EILINE(P)   TERN0(HAS_I_MIN,  DEFER4(MATCH_EILINE)(P, I_MIN_PIN))
-#define MATCH_J_MAX_EILINE(P)   TERN0(HAS_J_MAX,  DEFER4(MATCH_EILINE)(P, J_MAX_PIN))
-#define MATCH_J_MIN_EILINE(P)   TERN0(HAS_J_MIN,  DEFER4(MATCH_EILINE)(P, J_MIN_PIN))
-#define MATCH_K_MAX_EILINE(P)   TERN0(HAS_K_MAX,  DEFER4(MATCH_EILINE)(P, K_MAX_PIN))
-#define MATCH_K_MIN_EILINE(P)   TERN0(HAS_K_MIN,  DEFER4(MATCH_EILINE)(P, K_MIN_PIN))
-#define MATCH_U_MAX_EILINE(P)   TERN0(HAS_U_MAX,  DEFER4(MATCH_EILINE)(P, U_MAX_PIN))
-#define MATCH_U_MIN_EILINE(P)   TERN0(HAS_U_MIN,  DEFER4(MATCH_EILINE)(P, U_MIN_PIN))
-#define MATCH_V_MAX_EILINE(P)   TERN0(HAS_V_MAX,  DEFER4(MATCH_EILINE)(P, V_MAX_PIN))
-#define MATCH_V_MIN_EILINE(P)   TERN0(HAS_V_MIN,  DEFER4(MATCH_EILINE)(P, V_MIN_PIN))
-#define MATCH_W_MAX_EILINE(P)   TERN0(HAS_W_MAX,  DEFER4(MATCH_EILINE)(P, W_MAX_PIN))
-#define MATCH_W_MIN_EILINE(P)   TERN0(HAS_W_MIN,  DEFER4(MATCH_EILINE)(P, W_MIN_PIN))
-#define MATCH_Z2_MAX_EILINE(P)  TERN0(HAS_Z2_MAX, DEFER4(MATCH_EILINE)(P, Z2_MAX_PIN))
-#define MATCH_Z2_MIN_EILINE(P)  TERN0(HAS_Z2_MIN, DEFER4(MATCH_EILINE)(P, Z2_MIN_PIN))
-#define MATCH_Z3_MAX_EILINE(P)  TERN0(HAS_Z3_MAX, DEFER4(MATCH_EILINE)(P, Z3_MAX_PIN))
-#define MATCH_Z3_MIN_EILINE(P)  TERN0(HAS_Z3_MIN, DEFER4(MATCH_EILINE)(P, Z3_MIN_PIN))
-#define MATCH_Z4_MAX_EILINE(P)  TERN0(HAS_Z4_MAX, DEFER4(MATCH_EILINE)(P, Z4_MAX_PIN))
-#define MATCH_Z4_MIN_EILINE(P)  TERN0(HAS_Z4_MIN, DEFER4(MATCH_EILINE)(P, Z4_MIN_PIN))
-#define MATCH_Z_MIN_PROBE_EILINE(P) TERN0(HAS_Z_MIN_PROBE_PIN, DEFER4(MATCH_EILINE)(P, Z_MIN_PROBE_PIN))
-
-#define AVAILABLE_EILINE(P) ( PIN_TO_EILINE(P) != -1    \
-  && !MATCH_X_MAX_EILINE(P) && !MATCH_X_MIN_EILINE(P)   \
-  && !MATCH_Y_MAX_EILINE(P) && !MATCH_Y_MIN_EILINE(P)   \
-  && !MATCH_Z_MAX_EILINE(P) && !MATCH_Z_MIN_EILINE(P)   \
-  && !MATCH_I_MAX_EILINE(P) && !MATCH_I_MIN_EILINE(P)   \
-  && !MATCH_J_MAX_EILINE(P) && !MATCH_J_MIN_EILINE(P)   \
-  && !MATCH_K_MAX_EILINE(P) && !MATCH_K_MIN_EILINE(P)   \
-  && !MATCH_U_MAX_EILINE(P) && !MATCH_U_MIN_EILINE(P)   \
-  && !MATCH_V_MAX_EILINE(P) && !MATCH_V_MIN_EILINE(P)   \
-  && !MATCH_W_MAX_EILINE(P) && !MATCH_W_MIN_EILINE(P)   \
-  && !MATCH_Z2_MAX_EILINE(P) && !MATCH_Z2_MIN_EILINE(P) \
-  && !MATCH_Z3_MAX_EILINE(P) && !MATCH_Z3_MIN_EILINE(P) \
-  && !MATCH_Z4_MAX_EILINE(P) && !MATCH_Z4_MIN_EILINE(P) \
-  && !MATCH_Z_MIN_PROBE_EILINE(P) )
-
-// One ISR for all EXT-Interrupts
-void endstop_ISR() { endstops.update(); }
-
-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(P, endstop_ISR, CHANGE)
-  #if HAS_X_MAX
-    #if !AVAILABLE_EILINE(X_MAX_PIN)
-      #error "X_MAX_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(X_MAX_PIN);
-  #endif
-  #if HAS_X_MIN
-    #if !AVAILABLE_EILINE(X_MIN_PIN)
-      #error "X_MIN_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(X_MIN_PIN);
-  #endif
-  #if HAS_Y_MAX
-    #if !AVAILABLE_EILINE(Y_MAX_PIN)
-      #error "Y_MAX_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Y_MAX_PIN);
-  #endif
-  #if HAS_Y_MIN
-    #if !AVAILABLE_EILINE(Y_MIN_PIN)
-      #error "Y_MIN_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Y_MIN_PIN);
-  #endif
-  #if HAS_Z_MAX
-    #if !AVAILABLE_EILINE(Z_MAX_PIN)
-      #error "Z_MAX_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z_MAX_PIN);
-  #endif
-  #if HAS_Z_MIN
-    #if !AVAILABLE_EILINE(Z_MIN_PIN)
-      #error "Z_MIN_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z_MIN_PIN);
-  #endif
-  #if HAS_Z2_MAX
-    #if !AVAILABLE_EILINE(Z2_MAX_PIN)
-      #error "Z2_MAX_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z2_MAX_PIN);
-  #endif
-  #if HAS_Z2_MIN
-    #if !AVAILABLE_EILINE(Z2_MIN_PIN)
-      #error "Z2_MIN_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z2_MIN_PIN);
-  #endif
-  #if HAS_Z3_MAX
-    #if !AVAILABLE_EILINE(Z3_MAX_PIN)
-      #error "Z3_MAX_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z3_MAX_PIN);
-  #endif
-  #if HAS_Z3_MIN
-    #if !AVAILABLE_EILINE(Z3_MIN_PIN)
-      #error "Z3_MIN_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z3_MIN_PIN);
-  #endif
-  #if HAS_Z4_MAX
-    #if !AVAILABLE_EILINE(Z4_MAX_PIN)
-      #error "Z4_MAX_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z4_MAX_PIN);
-  #endif
-  #if HAS_Z4_MIN
-    #if !AVAILABLE_EILINE(Z4_MIN_PIN)
-      #error "Z4_MIN_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z4_MIN_PIN);
-  #endif
-  #if HAS_Z_MIN_PROBE_PIN
-    #if !AVAILABLE_EILINE(Z_MIN_PROBE_PIN)
-      #error "Z_MIN_PROBE_PIN has no EXTINT line available."
-    #endif
-    _ATTACH(Z_MIN_PROBE_PIN);
-  #endif
-  #if HAS_I_MAX
-    #if !AVAILABLE_EILINE(I_MAX_PIN)
-      #error "I_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(I_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_I_MIN
-    #if !AVAILABLE_EILINE(I_MIN_PIN)
-      #error "I_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(I_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_J_MAX
-    #if !AVAILABLE_EILINE(J_MAX_PIN)
-      #error "J_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(J_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_J_MIN
-    #if !AVAILABLE_EILINE(J_MIN_PIN)
-      #error "J_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(J_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_K_MAX
-    #if !AVAILABLE_EILINE(K_MAX_PIN)
-      #error "K_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(K_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_K_MIN
-    #if !AVAILABLE_EILINE(K_MIN_PIN)
-      #error "K_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(K_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_U_MAX
-    #if !AVAILABLE_EILINE(U_MAX_PIN)
-      #error "U_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(U_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_U_MIN
-    #if !AVAILABLE_EILINE(U_MIN_PIN)
-      #error "U_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(U_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_V_MAX
-    #if !AVAILABLE_EILINE(V_MAX_PIN)
-      #error "V_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(V_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_V_MIN
-    #if !AVAILABLE_EILINE(V_MIN_PIN)
-      #error "V_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(V_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_W_MAX
-    #if !AVAILABLE_EILINE(W_MAX_PIN)
-      #error "W_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(W_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_W_MIN
-    #if !AVAILABLE_EILINE(W_MIN_PIN)
-      #error "W_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(W_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-}
@@ -1,216 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-/**
- * Fast IO functions for SAMD21
- */
-
-#include "SAMD21.h"
-
-/**
- * Utility functions
- */
-
-#ifndef MASK
-  #define MASK(PIN) _BV(PIN)
-#endif
-
-/**
- * Magic I/O routines
- *
- * Now you can simply SET_OUTPUT(IO); WRITE(IO, HIGH); WRITE(IO, LOW);
- */
-
-// Read a pin
-#define READ(IO)        ((PORT->Group[(EPortType)GET_SAMD_PORT(IO)].IN.reg & MASK(GET_SAMD_PIN(IO))) != 0)
-
-// Write to a pin
-#define WRITE(IO,V)     do{                                                     \
-                          const EPortType port = (EPortType)GET_SAMD_PORT(IO);  \
-                          const uint32_t mask = MASK(GET_SAMD_PIN(IO));         \
-                                                                                \
-                          if (V) PORT->Group[port].OUTSET.reg = mask;           \
-                          else PORT->Group[port].OUTCLR.reg = mask;             \
-                        }while(0)
-
-// Toggle a pin
-#define TOGGLE(IO)      PORT->Group[(EPortType)GET_SAMD_PORT(IO)].OUTTGL.reg = MASK(GET_SAMD_PIN(IO));
-
-// Set pin as input
-#define SET_INPUT(IO)           do{                                                                 \
-                                  const EPortType port = (EPortType)GET_SAMD_PORT(IO);              \
-                                  const uint32_t pin = GET_SAMD_PIN(IO);                            \
-                                                                                                    \
-                                  PORT->Group[port].PINCFG[pin].reg = (uint8_t)(PORT_PINCFG_INEN);  \
-                                  PORT->Group[port].DIRCLR.reg = MASK(pin);                         \
-                                }while(0)
-// Set pin as input with pullup
-#define SET_INPUT_PULLUP(IO)    do{                                                                                       \
-                                  const EPortType port = (EPortType)GET_SAMD_PORT(IO);                                    \
-                                  const uint32_t pin = GET_SAMD_PIN(IO);                                                  \
-                                  const uint32_t mask = MASK(pin);                                                        \
-                                                                                                                          \
-                                  PORT->Group[port].PINCFG[pin].reg = (uint8_t)(PORT_PINCFG_INEN | PORT_PINCFG_PULLEN);   \
-                                  PORT->Group[port].DIRCLR.reg = mask;                                                    \
-                                  PORT->Group[port].OUTSET.reg = mask;                                                    \
-                                }while(0)
-// Set pin as input with pulldown
-#define SET_INPUT_PULLDOWN(IO)  do{                                                                                       \
-                                  const EPortType port = (EPortType)GET_SAMD_PORT(IO);                                    \
-                                  const uint32_t pin = GET_SAMD_PIN(IO);                                                  \
-                                  const uint32_t mask = MASK(pin);                                                        \
-                                                                                                                          \
-                                  PORT->Group[port].PINCFG[pin].reg = (uint8_t)(PORT_PINCFG_INEN | PORT_PINCFG_PULLEN);   \
-                                  PORT->Group[port].DIRCLR.reg = mask;                                                    \
-                                  PORT->Group[port].OUTCLR.reg = mask;                                                    \
-                                }while(0)
-// Set pin as output (push pull)
-#define SET_OUTPUT(IO)          do{                                                                 \
-                                  const EPortType port = (EPortType)GET_SAMD_PORT(IO);              \
-                                  const uint32_t pin = GET_SAMD_PIN(IO);                            \
-                                                                                                    \
-                                  PORT->Group[port].DIRSET.reg = MASK(pin);                         \
-                                  PORT->Group[port].PINCFG[pin].reg = 0;                            \
-                                }while(0)
-// Set pin as output (open drain)
-#define SET_OUTPUT_OD(IO)       do{                                                                   \
-                                  const EPortType port = (EPortType)GET_SAMD_PORT(IO);                \
-                                  const uint32_t pin = GET_SAMD_PIN(IO);                              \
-                                                                                                      \
-                                  PORT->Group[port].PINCFG[pin].reg = (uint8_t)(PORT_PINCFG_PULLEN);  \
-                                  PORT->Group[port].DIRCLR.reg = MASK(pin);                           \
-                                }while(0)
-// Set pin as PWM (push pull)
-#define SET_PWM                 SET_OUTPUT
-// Set pin as PWM (open drain)
-#define SET_PWM_OD              SET_OUTPUT_OD
-
-// check if pin is an output
-#define IS_OUTPUT(IO)            ((PORT->Group[(EPortType)GET_SAMD_PORT(IO)].DIR.reg & MASK(GET_SAMD_PIN(IO))) \
-                                 || (PORT->Group[(EPortType)GET_SAMD_PORT(IO)].PINCFG[GET_SAMD_PIN(IO)].reg & (PORT_PINCFG_INEN | PORT_PINCFG_PULLEN)) == PORT_PINCFG_PULLEN)
-// check if pin is an input
-#define IS_INPUT(IO)            !IS_OUTPUT(IO)
-
-// Shorthand
-#define OUT_WRITE(IO,V)         do{ SET_OUTPUT(IO); WRITE(IO,V); }while(0)
-#define OUT_WRITE_OD(IO,V)      do{ SET_OUTPUT_OD(IO); WRITE(IO,V); }while(0)
-
-// digitalRead/Write wrappers
-#define extDigitalRead(IO)      digitalRead(IO)
-#define extDigitalWrite(IO,V)   digitalWrite(IO,V)
-
-/**
- * Ports and functions
- * Added as necessary or if I feel like it- not a comprehensive list!
- */
-
-/*
- * Some of these share the same source and so can't be used in the same time
- */
-#define PWM_PIN(P)        (WITHIN(P, 2, 13) || WITHIN(P, 22, 23) || WITHIN(P, 44, 45) || P == 48)
-
-// Return fulfilled ADCx->INPUTCTRL.reg
-#define PIN_TO_INPUTCTRL(P)     (  (P == 0) ? ADC_INPUTCTRL_MUXPOS_PIN0   \
-                                 : ((P) == 1) ? ADC_INPUTCTRL_MUXPOS_PIN1   \
-                                 : ((P) == 2) ? ADC_INPUTCTRL_MUXPOS_PIN3   \
-                                 : ((P) == 3) ? ADC_INPUTCTRL_MUXPOS_PIN4   \
-                                 : ((P) == 4) ? ADC_INPUTCTRL_MUXPOS_PIN5   \
-                                 : ((P) == 5) ? ADC_INPUTCTRL_MUXPOS_PIN5   \
-                                 : ((P) == 6) ? ADC_INPUTCTRL_MUXPOS_PIN6   \
-                                 : ((P) == 7) ? ADC_INPUTCTRL_MUXPOS_PIN7   \
-                                 : ((P) == 8) ? ADC_INPUTCTRL_MUXPOS_PIN8   \
-                                 : ((P) == 9) ? ADC_INPUTCTRL_MUXPOS_PIN9   \
-                                 : ((P) == 10) ? ADC_INPUTCTRL_MUXPOS_PIN10 \
-                                 : ((P) == 11) ? ADC_INPUTCTRL_MUXPOS_PIN11 \
-                                 : ((P) == 12) ? ADC_INPUTCTRL_MUXPOS_PIN12 \
-                                 : ((P) == 13) ? ADC_INPUTCTRL_MUXPOS_PIN13 \
-                                 : ((P) == 14) ? ADC_INPUTCTRL_MUXPOS_PIN14 \
-                                 : ADC_INPUTCTRL_MUXPOS_PIN15)
-
-#define digitalPinToAnalogInput(P) (WITHIN(P, 67, 74) ? (P) - 67 : WITHIN(P, 54, 61) ? 8 + (P) - 54 : WITHIN(P, 12, 13) ? 16 + (P) - 12 : P == 9 ? 18 : -1)
-
-/**
- * pins
- */
-
-// PORTA
-#define DIO28_PIN   PIN_PA02    // A0
-#define DIO56_PIN   PIN_PA03    // A13
-#define DIO31_PIN   PIN_PA04    // A13
-#define DIO32_PIN   PIN_PA05    // A1
-#define DIO8_PIN    PIN_PA06    // A14
-#define DIO9_PIN    PIN_PA07    // A15
-#define DIO4_PIN    PIN_PA08    // A15
-#define DIO3_PIN    PIN_PA09    // A15
-#define DIO1_PIN    PIN_PA10
-#define DIO0_PIN    PIN_PA11
-#define DIO18_PIN   PIN_PA12
-#define DIO52_PIN   PIN_PA13
-#define DIO2_PIN    PIN_PA14
-#define DIO5_PIN    PIN_PA15
-#define DIO11_PIN   PIN_PA16
-#define DIO13_PIN   PIN_PA17
-#define DIO10_PIN   PIN_PA18
-#define DIO12_PIN   PIN_PA19
-#define DIO6_PIN    PIN_PA20
-#define DIO07_PIN   PIN_PA21
-#define DIO34_PIN   PIN_PA22
-#define DIO35_PIN   PIN_PA23
-#define DIO42_PIN   PIN_PA24
-#define DIO43_PIN   PIN_PA25
-
-#define DIO40_PIN   PIN_PA27
-
-#define DIO26_PIN   PIN_PB00
-#define DIO27_PIN   PIN_PB01    // A0
-#define DIO33_PIN   PIN_PB02
-#define DIO39_PIN   PIN_PB03
-#define DIO14_PIN   PIN_PB04
-#define DIO15_PIN   PIN_PB05
-#define DIO16_PIN   PIN_PB06
-#define DIO17_PIN   PIN_PB07
-#define DIO29_PIN   PIN_PB08
-#define DIO30_PIN   PIN_PB09
-#define DIO37_PIN   PIN_PB10
-#define DIO38_PIN   PIN_PB11
-#define DIO36_PIN   PIN_PB12
-#define DIO19_PIN   PIN_PB13
-#define DIO20_PIN   PIN_PB14
-#define DIO21_PIN   PIN_PB15
-#define DIO22_PIN   PIN_PB16
-#define DIO23_PIN   PIN_PB17
-
-#define DIO44_PIN   PIN_PB22
-#define DIO45_PIN   PIN_PB23
-#define DIO24_PIN   PIN_PB30
-#define DIO25_PIN   PIN_PB31
-
-#define DIO53_PIN   PIN_PA21
-#define DIO54_PIN   PIN_PA06
-#define DIO55_PIN   PIN_PA07
-
@@ -1,31 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#pragma once
-
-#if HAS_SPI_TFT || HAS_FSMC_TFT
-  #error "Sorry! TFT displays are not available for HAL/SAMD21."
-#endif
@@ -1,27 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#pragma once
@@ -1,33 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#pragma once
-
-#if USE_FALLBACK_EEPROM
-  #define FLASH_EEPROM_EMULATION
-#elif EITHER(I2C_EEPROM, SPI_EEPROM)
-  #define USE_SHARED_EEPROM 1
-#endif
@@ -1,50 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-/**
- * Test SAMD21 specific configuration values for errors at compile-time.
- */
-
-#if SERVO_TC == MF_TIMER_RTC
-  #error "Servos can't use RTC timer"
-#endif
-
-#if ENABLED(EMERGENCY_PARSER)
-  #error "EMERGENCY_PARSER is not yet implemented for SAMD21. Disable EMERGENCY_PARSER to continue."
-#endif
-
-#if ENABLED(SDIO_SUPPORT)
-  #error "SDIO_SUPPORT is not supported on SAMD21."
-#endif
-
-#if ENABLED(FAST_PWM_FAN)
-  #error "Features requiring Hardware PWM (FAST_PWM_FAN) are not yet supported on SAMD21."
-#endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on SAMD21."
-#endif
@@ -1,160 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-#define NUMBER_PINS_TOTAL PINS_COUNT
-
-#define digitalRead_mod(p) extDigitalRead(p)
-#define PRINT_PORT(p) do{ SERIAL_ECHOPGM("  Port: "); sprintf_P(buffer, PSTR("%c%02ld"), 'A' + g_APinDescription[p].ulPort, g_APinDescription[p].ulPin); SERIAL_ECHO(buffer); }while (0)
-#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
-#define GET_ARRAY_PIN(p) pin_array[p].pin
-#define GET_ARRAY_IS_DIGITAL(p) pin_array[p].is_digital
-#define VALID_PIN(pin) (pin >= 0 && pin < (int8_t)NUMBER_PINS_TOTAL)
-#define DIGITAL_PIN_TO_ANALOG_PIN(p) digitalPinToAnalogInput(p)
-#define IS_ANALOG(P) (DIGITAL_PIN_TO_ANALOG_PIN(P)!=-1)
-#define pwm_status(pin) digitalPinHasPWM(pin)
-#define MULTI_NAME_PAD 27 // space needed to be pretty if not first name assigned to a pin
-
-// pins that will cause hang/reset/disconnect in M43 Toggle and Watch utilities
-// uses pin index
-#define M43_NEVER_TOUCH(Q) ((Q) >= 75)
-
-bool GET_PINMODE(int8_t pin) {  // 1: output, 0: input
-  const EPortType samdport = g_APinDescription[pin].ulPort;
-  const uint32_t samdpin = g_APinDescription[pin].ulPin;
-  return PORT->Group[samdport].DIR.reg & MASK(samdpin) || (PORT->Group[samdport].PINCFG[samdpin].reg & (PORT_PINCFG_INEN | PORT_PINCFG_PULLEN)) == PORT_PINCFG_PULLEN;
-}
-
-void pwm_details(int32_t pin) {
-  if (pwm_status(pin)) {
-    //uint32_t chan = g_APinDescription[pin].ulPWMChannel TODO when fast pwm is operative;
-    //SERIAL_ECHOPGM("PWM = ", duty);
-  }
-}
-
-/**
- * SAMD21 Board pin|  PORT  | Label
- * ----------------+--------+-------
- *   0             |  PB25  | "RX0"
- *   1             |  PB24  | "TX0"
- *   2             |  PC18  |
- *   3             |  PC19  |
- *   4             |  PC20  |
- *   5             |  PC21  |
- *   6             |  PD20  |
- *   7             |  PD21  |
- *   8             |  PB18  |
- *   9             |  PB2   |
- *  10             |  PB22  |
- *  11             |  PB23  |
- *  12             |  PB0   | "A16"
- *  13             |  PB1   | LED AMBER "L" / "A17"
- *  14             |  PB16  | "TX3"
- *  15             |  PB17  | "RX3"
- *  16             |  PC22  | "TX2"
- *  17             |  PC23  | "RX2"
- *  18             |  PB12  | "TX1" / "A18"
- *  19             |  PB13  | "RX1"
- *  20             |  PB20  | "SDA"
- *  21             |  PB21  | "SCL"
- *  22             |  PD12  |
- *  23             |  PA15  |
- *  24             |  PC17  |
- *  25             |  PC16  |
- *  26             |  PA12  |
- *  27             |  PA13  |
- *  28             |  PA14  |
- *  29             |  PB19  |
- *  30             |  PA23  |
- *  31             |  PA22  |
- *  32             |  PA21  |
- *  33             |  PA20  |
- *  34             |  PA19  |
- *  35             |  PA18  |
- *  36             |  PA17  |
- *  37             |  PA16  |
- *  38             |  PB15  |
- *  39             |  PB14  |
- *  40             |  PC13  |
- *  41             |  PC12  |
- *  42             |  PC15  |
- *  43             |  PC14  |
- *  44             |  PC11  |
- *  45             |  PC10  |
- *  46             |  PC6   |
- *  47             |  PC7   |
- *  48             |  PC4   |
- *  49             |  PC5   |
- *  50             |  PD11  |
- *  51             |  PD8   |
- *  52             |  PD9   |
- *  53             |  PD10  |
- *  54             |  PB5   | "A8"
- *  55             |  PB6   | "A9"
- *  56             |  PB7   | "A10"
- *  57             |  PB8   | "A11"
- *  58             |  PB9   | "A12"
- *  69             |  PA4   | "A13"
- *  60             |  PA6   | "A14"
- *  61             |  PA7   | "A15"
- *  62             |  PB17  |
- *  63             |  PB20  |
- *  64             |  PD11  |
- *  65             |  PD8   |
- *  66             |  PD9   |
- *  67             |  PA2   | "A0" / "DAC0"
- *  68             |  PA5   | "A1" / "DAC1"
- *  69             |  PB3   | "A2"
- *  70             |  PC0   | "A3"
- *  71             |  PC1   | "A4"
- *  72             |  PC2   | "A5"
- *  73             |  PC3   | "A6"
- *  74             |  PB4   | "A7"
- *  75             |  PC31  | LED GREEN "RX"
- *  76             |  PC30  | LED GREEN "TX"
- *  77             |  PA27  | USB: Host enable
- *  78             |  PA24  | USB: D-
- *  79             |  PA25  | USB: D+
- *  80             |  PB29  | SD: MISO
- *  81             |  PB27  | SD: SCK
- *  82             |  PB26  | SD: MOSI
- *  83             |  PB28  | SD: CS
- *  84             |  PA3   | AREF
- *  85             |  PA2   | DAC0 (Duplicate)
- *  86             |  PA5   | DAC1 (Duplicate)
- *  87             |  PB1   | LED AMBER "L" (Duplicate)
- *  88             |  PC24  | NeoPixel
- *  89             |  PB10  | QSPI: SCK
- *  90             |  PB11  | QSPI: CS
- *  91             |  PA8   | QSPI: IO0
- *  92             |  PA9   | QSPI: IO1
- *  93             |  PA10  | QSPI: IO2
- *  94             |  PA11  | QSPI: IO3
- *  95             |  PB31  | SD: DETECT
- */
@@ -1,54 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-/**
- * SAMD21 Default SPI Pins
- *
- *         SS    SCK   MISO   MOSI
- *       +-------------------------+
- *  SPI  | 53    52     50     51  |
- *  SPI1 | 83    81     80     82  |
- *       +-------------------------+
- * Any pin can be used for Chip Select (SD_SS_PIN)
- */
-#ifndef SD_SCK_PIN
-  #define SD_SCK_PIN    38
-#endif
-#ifndef SD_MISO_PIN
-  #define SD_MISO_PIN   36
-#endif
-#ifndef SD_MOSI_PIN
-  #define SD_MOSI_PIN   37
-#endif
-#ifndef SDSS
-  #define SDSS          18
-#endif
-
-#ifndef SD_SS_PIN
-  #define SD_SS_PIN     SDSS
-#endif
@@ -1,217 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#ifdef __SAMD21__
-
-// --------------------------------------------------------------------------
-// Includes
-// --------------------------------------------------------------------------
-
-#include "../../inc/MarlinConfig.h"
-#include "ServoTimers.h" // for SERVO_TC
-
-// --------------------------------------------------------------------------
-// Local defines
-// --------------------------------------------------------------------------
-
-#define NUM_HARDWARE_TIMERS 9
-
-// --------------------------------------------------------------------------
-// Private Variables
-// --------------------------------------------------------------------------
-
-const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
-  { {.pTcc=TCC0}, TimerType::tcc,  TCC0_IRQn, TC_PRIORITY(0) },  // 0 - stepper (assigned priority 2)
-  { {.pTcc=TCC1}, TimerType::tcc,  TCC1_IRQn, TC_PRIORITY(1) },  // 1 - stepper (needed by 32 bit timers)
-  { {.pTcc=TCC2}, TimerType::tcc,  TCC2_IRQn, 5              },  // 2 - tone (reserved by framework and fixed assigned priority 5)
-  { {.pTc=TC3},   TimerType::tc,   TC3_IRQn,  TC_PRIORITY(3) },  // 3 - servo (assigned priority 1)
-  { {.pTc=TC4},   TimerType::tc,   TC4_IRQn,  TC_PRIORITY(4) },  // 4 - software serial (no interrupts used)
-  { {.pTc=TC5},   TimerType::tc,   TC5_IRQn,  TC_PRIORITY(5) },
-  { {.pTc=TC6},   TimerType::tc,   TC6_IRQn,  TC_PRIORITY(6) },
-  { {.pTc=TC7},   TimerType::tc,   TC7_IRQn,  TC_PRIORITY(7) },
-  { {.pRtc=RTC},  TimerType::rtc,   RTC_IRQn, TC_PRIORITY(8) }   // 8 - temperature (assigned priority 6)
-};
-
-// --------------------------------------------------------------------------
-// Private functions
-// --------------------------------------------------------------------------
-
-FORCE_INLINE void Disable_Irq(IRQn_Type irq) {
-  NVIC_DisableIRQ(irq);
-
-  // We NEED memory barriers to ensure Interrupts are actually disabled!
-  // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-  __DSB();
-  __ISB();
-}
-
-static bool tcIsSyncing(Tc * tc) {
-  return tc->COUNT32.STATUS.reg & TC_STATUS_SYNCBUSY;
-}
-
-static void tcReset( Tc * tc) {
-  tc->COUNT32.CTRLA.reg = TC_CTRLA_SWRST;
-  while (tcIsSyncing(tc)) {}
-  while (tc->COUNT32.CTRLA.bit.SWRST) {}
-}
-
-// --------------------------------------------------------------------------
-// Public functions
-// --------------------------------------------------------------------------
-
-void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
-  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
-
-  // Disable interrupt, just in case it was already enabled
-  NVIC_DisableIRQ(irq);
-  NVIC_ClearPendingIRQ(irq);
-
-  if (timer_num == MF_TIMER_RTC) {
-
-    // https://github.com/arduino-libraries/RTCZero
-    Rtc * const rtc = timer_config[timer_num].pRtc;
-    PM->APBAMASK.reg |= PM_APBAMASK_RTC;
-
-    GCLK->CLKCTRL.reg = (uint32_t)((GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK4 | (RTC_GCLK_ID << GCLK_CLKCTRL_ID_Pos)));
-    while (GCLK->STATUS.bit.SYNCBUSY) {}
-
-    GCLK->GENCTRL.reg = (GCLK_GENCTRL_GENEN | GCLK_GENCTRL_SRC_OSCULP32K | GCLK_GENCTRL_ID(4) | GCLK_GENCTRL_DIVSEL );
-    while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY) {}
-
-    GCLK->GENDIV.reg = GCLK_GENDIV_ID(4);
-    GCLK->GENDIV.bit.DIV=4;
-    while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY) {}
-
-    // Disable timer interrupt
-    rtc->MODE0.INTENCLR.reg = RTC_MODE0_INTENCLR_CMP0;
-    SYNC(rtc->MODE0.STATUS.bit.SYNCBUSY);
-
-    while(rtc->MODE0.STATUS.bit.SYNCBUSY) {}
-
-    // Stop timer, just in case, to be able to reconfigure it
-    rtc->MODE0.CTRL.reg =
-      RTC_MODE0_CTRL_MODE_COUNT32 |           // Mode 0 = 32-bits counter
-      RTC_MODE0_CTRL_PRESCALER_DIV1024;       // Divisor = 1024
-
-    while(rtc->MODE0.STATUS.bit.SYNCBUSY) {}
-
-    // Mode, reset counter on match
-    rtc->MODE0.CTRL.reg = RTC_MODE0_CTRL_MODE_COUNT32 | RTC_MODE0_CTRL_MATCHCLR;
-
-    // Set compare value
-    rtc->MODE0.COMP[0].reg = (32768 + frequency / 2) / frequency;
-    SYNC(rtc->MODE0.STATUS.bit.SYNCBUSY);
-
-    // Enable interrupt on compare
-    rtc->MODE0.INTFLAG.reg = RTC_MODE0_INTFLAG_CMP0;    // reset pending interrupt
-    rtc->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_CMP0;  // enable compare 0 interrupt
-
-    // And start timer
-    rtc->MODE0.CTRL.bit.ENABLE = true;
-    SYNC(rtc->MODE0.STATUS.bit.SYNCBUSY);
-
-  }
-  else if (timer_config[timer_num].type==TimerType::tcc) {
-
-    Tcc * const tc = timer_config[timer_num].pTcc;
-
-    PM->APBCMASK.reg |= PM_APBCMASK_TCC0;
-     GCLK->CLKCTRL.reg =(GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_ID(TCC0_GCLK_ID));
-    SYNC (GCLK->STATUS.bit.SYNCBUSY);
-
-    tc->CTRLA.reg = TCC_CTRLA_SWRST;
-    SYNC (tc->SYNCBUSY.reg & TCC_SYNCBUSY_SWRST) {}
-
-    SYNC (tc->CTRLA.bit.SWRST);
-
-    tc->CTRLA.reg &= ~(TCC_CTRLA_ENABLE);       // disable TC module
-
-    tc->CTRLA.reg |= TCC_WAVE_WAVEGEN_MFRQ;
-    tc->CTRLA.reg |= TCC_CTRLA_PRESCALER_DIV2;
-    tc->CC[0].reg = (HAL_TIMER_RATE) / frequency;
-    tc->INTENSET.reg = TCC_INTFLAG_MC0;
-    tc->CTRLA.reg |= TCC_CTRLA_ENABLE;
-    tc->INTFLAG.reg = 0xFF;
-    SYNC ( tc->STATUS.reg & TC_STATUS_SYNCBUSY);
-
-  }
-  else {
-    Tc * const tc = timer_config[timer_num].pTc;
-
-    // Disable timer interrupt
-    tc->COUNT32.INTENCLR.reg = TC_INTENCLR_OVF; // disable overflow interrupt
-
-    // TCn clock setup
-    GCLK->CLKCTRL.reg = (uint16_t) (GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK0  | GCLK_CLKCTRL_ID(GCM_TC4_TC5)) ;
-    SYNC (GCLK->STATUS.bit.SYNCBUSY);
-
-    tcReset(tc); // reset TC
-
-    // Set Timer counter 5 Mode to 16 bits, it will become a 16bit counter ('mode1' in the datasheet)
-    tc->COUNT32.CTRLA.reg |= TC_CTRLA_MODE_COUNT32;
-    // Set TC waveform generation mode to 'match frequency'
-    tc->COUNT32.CTRLA.reg |= TC_CTRLA_WAVEGEN_MFRQ;
-    //set prescaler
-    //the clock normally counts at the GCLK_TC frequency, but we can set it to divide that frequency to slow it down
-    //you can use different prescaler divisons here like TC_CTRLA_PRESCALER_DIV1 to get a different range
-    tc->COUNT32.CTRLA.reg |= TC_CTRLA_PRESCALER_DIV1 | TC_CTRLA_ENABLE; //it will divide GCLK_TC frequency by 1024
-    //set the compare-capture register.
-    //The counter will count up to this value (it's a 16bit counter so we use uint16_t)
-    //this is how we fine-tune the frequency, make it count to a lower or higher value
-    //system clock should be 1MHz (8MHz/8) at Reset by default
-    tc->COUNT32.CC[0].reg = (uint16_t) (HAL_TIMER_RATE / frequency);
-    while (tcIsSyncing(tc)) {}
-
-    // Enable the TC interrupt request
-    tc->COUNT32.INTENSET.bit.MC0 = 1;
-    while (tcIsSyncing(tc)) {}
-  }
-
-  NVIC_SetPriority(irq, timer_config[timer_num].priority);
-  NVIC_EnableIRQ(irq);
-}
-
-void HAL_timer_enable_interrupt(const uint8_t timer_num) {
-  const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
-  NVIC_EnableIRQ(irq);
-}
-
-void HAL_timer_disable_interrupt(const uint8_t timer_num) {
-  const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
-  Disable_Irq(irq);
-}
-
-// missing from CMSIS: Check if interrupt is enabled or not
-static bool NVIC_GetEnabledIRQ(IRQn_Type IRQn) {
-  return TEST(NVIC->ISER[uint32_t(IRQn) >> 5], uint32_t(IRQn) & 0x1F);
-}
-
-bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
-  const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
-  return NVIC_GetEnabledIRQ(irq);
-}
-
-#endif // __SAMD21__
@@ -1,160 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-#include <stdint.h>
-
-// --------------------------------------------------------------------------
-// Defines
-// --------------------------------------------------------------------------
-
-typedef uint32_t hal_timer_t;
-#define HAL_TIMER_TYPE_MAX 0xFFFFFFFF
-
-#define HAL_TIMER_RATE      F_CPU   // frequency of timers peripherals
-
-#define MF_TIMER_RTC            8   // This is not a TC but a RTC
-
-#ifndef MF_TIMER_STEP
-  #define MF_TIMER_STEP         4   // Timer Index for Stepper
-#endif
-#ifndef MF_TIMER_PULSE
-  #define MF_TIMER_PULSE        MF_TIMER_STEP
-#endif
-#ifndef MF_TIMER_TEMP
-  #define MF_TIMER_TEMP         MF_TIMER_RTC // Timer Index for Temperature
-#endif
-
-#define TEMP_TIMER_FREQUENCY   1000 // temperature interrupt frequency
-
-#define STEPPER_TIMER_RATE          HAL_TIMER_RATE   // frequency of stepper timer (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)
-#define STEPPER_TIMER_TICKS_PER_US  (STEPPER_TIMER_RATE / 1000000) // stepper timer ticks per µs
-#define STEPPER_TIMER_PRESCALE      (CYCLES_PER_MICROSECOND / STEPPER_TIMER_TICKS_PER_US)
-
-#define PULSE_TIMER_RATE          STEPPER_TIMER_RATE
-#define PULSE_TIMER_PRESCALE      STEPPER_TIMER_PRESCALE
-#define PULSE_TIMER_TICKS_PER_US  STEPPER_TIMER_TICKS_PER_US
-
-#define ENABLE_STEPPER_DRIVER_INTERRUPT()   HAL_timer_enable_interrupt(MF_TIMER_STEP)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(MF_TIMER_STEP)
-#define STEPPER_ISR_ENABLED()               HAL_timer_interrupt_enabled(MF_TIMER_STEP)
-
-#define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(MF_TIMER_TEMP)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
-
-#define TC_PRIORITY(t) (  t == SERVO_TC ? 1                              \
-                       : (t == MF_TIMER_STEP || t == MF_TIMER_PULSE) ? 2 \
-                       : (t == MF_TIMER_TEMP) ? 6 : 7 )
-
-#define _TC_HANDLER(t)          void TC##t##_Handler()
-#define TC_HANDLER(t)           _TC_HANDLER(t)
-#ifndef HAL_STEP_TIMER_ISR
-  #define HAL_STEP_TIMER_ISR()  TC_HANDLER(MF_TIMER_STEP)
-#endif
-#if MF_TIMER_STEP != MF_TIMER_PULSE
-  #define HAL_PULSE_TIMER_ISR() TC_HANDLER(MF_TIMER_PULSE)
-#endif
-#if MF_TIMER_TEMP == MF_TIMER_RTC
-  #define HAL_TEMP_TIMER_ISR()  void RTC_Handler()
-#else
-  #define HAL_TEMP_TIMER_ISR()  TC_HANDLER(MF_TIMER_TEMP)
-#endif
-
-// --------------------------------------------------------------------------
-// Types
-// --------------------------------------------------------------------------
-typedef enum  { tcc, tc, rtc } TimerType;
-
-typedef struct {
-  union {
-    Tc  *pTc;
-    Tcc *pTcc;
-    Rtc *pRtc;
-  };
-  TimerType type;
-  IRQn_Type   IRQ_Id;
-  uint8_t     priority;
-} tTimerConfig;
-
-// --------------------------------------------------------------------------
-// Public Variables
-// --------------------------------------------------------------------------
-
-extern const tTimerConfig timer_config[];
-
-// --------------------------------------------------------------------------
-// Public functions
-// --------------------------------------------------------------------------
-
-void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
-
-FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
-  // Should never be called with timer MF_TIMER_RTC
-  Tc * const tc = timer_config[timer_num].pTc;
-  tc->COUNT32.CC[0].reg = compare;
-}
-
-FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
-  // Should never be called with timer MF_TIMER_RTC
-  Tc * const tc = timer_config[timer_num].pTc;
-  return (hal_timer_t)tc->COUNT32.CC[0].reg;
-}
-
-FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
-  // Should never be called with timer MF_TIMER_RTC
-  Tc * const tc = timer_config[timer_num].pTc;
-  tc->COUNT32.READREQ.reg = TC_READREQ_RREQ;
-  // Request a read synchronization
-  SYNC (tc->COUNT32.STATUS.bit.SYNCBUSY);
-  //SYNC(tc->COUNT32.STATUS.bit.SYNCBUSY );
-  return tc->COUNT32.COUNT.reg;
-}
-
-void HAL_timer_enable_interrupt(const uint8_t timer_num);
-void HAL_timer_disable_interrupt(const uint8_t timer_num);
-bool HAL_timer_interrupt_enabled(const uint8_t timer_num);
-
-FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
-  if (timer_num == MF_TIMER_RTC) {
-    Rtc * const rtc = timer_config[timer_num].pRtc;
-    // Clear interrupt flag
-    rtc->MODE0.INTFLAG.reg = RTC_MODE0_INTFLAG_CMP0| RTC_MODE0_INTFLAG_OVF;
-
-  }
-  else if (timer_config[timer_num].type == TimerType::tcc){
-    Tcc * const tc = timer_config[timer_num].pTcc;
-    // Clear interrupt flag
-    tc->INTFLAG.reg = TCC_INTFLAG_OVF;
-  }
-  else {
-    Tc * const tc = timer_config[timer_num].pTc;
-    // Clear interrupt flag
-    tc->COUNT32.INTFLAG.bit.MC0 = 1;
-  }
-}
-
-#define HAL_timer_isr_epilogue(timer_num)
@@ -1,32 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-// adapted from  I2C/master/master.c example
-//   https://www-users.cs.york.ac.uk/~pcc/MCP/HAPR-Course-web/CMSIS/examples/html/master_8c_source.html
-
-#ifdef __SAMD21__
-
-#endif // __SAMD21__
@@ -1,27 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#pragma once
@@ -1,41 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#pragma once
-
-/**
- * SAMD21 LCD-specific defines
- */
-
-// The following are optional depending on the platform.
-
-// definitions of HAL specific com and device drivers.
-uint8_t u8g_com_samd21_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
-uint8_t u8g_com_samd21_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
-
-// connect U8g com generic com names to the desired driver
-#define U8G_COM_HW_SPI u8g_com_samd21_st7920_hw_spi_fn  // use SAMD21 specific hardware SPI routine
-#define U8G_COM_ST7920_HW_SPI u8g_com_samd21_st7920_hw_spi_fn
@@ -1,42 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-/**
- * Low level pin manipulation routines - used by all the drivers.
- *
- * These are based on the SAMD51 pinMode, digitalRead & digitalWrite routines.
- *
- * Couldn't just call exact copies because the overhead killed the LCD update speed
- * With an intermediate level the softspi was running in the 10-20kHz range which
- * resulted in using about about 25% of the CPU's time.
- */
-
-#ifdef __SAMD21__
-
-#include <Arduino.h>
-
-#endif // __SAMD21__
@@ -1,42 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-#pragma once
-
-/**
- * Low level pin manipulation routines - used by all the drivers.
- *
- * These are based on the SAMD51 pinMode, digitalRead & digitalWrite routines.
- *
- * Couldn't just call exact copies because the overhead killed the LCD update speed
- * With an intermediate level the softspi was running in the 10-20kHz range which
- * resulted in using about about 25% of the CPU's time.
- */
-
-void u8g_SetPinOutput(uint8_t internal_pin_number);
-void u8g_SetPinInput(uint8_t internal_pin_number);
-void u8g_SetPinLevel(uint8_t  pin, uint8_t  pin_status);
-uint8_t u8g_GetPinLevel(uint8_t pin);
@@ -1,154 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * SAMD21 HAL developed by Bart Meijer (brupje)
- * Based on SAMD51 HAL by Giuliano Zaro (AKA GMagician)
- */
-
-/**
- * Based on u8g_com_msp430_hw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2012, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice, this list
- * of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright notice, this
- * list of conditions and the following disclaimer in the documentation and/or other
- * materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifdef __SAMD21__
-
-#include <U8glib-HAL.h>
-#include "SPI.h"
-
-#include "../../shared/HAL_SPI.h"
-
-#ifndef LCD_SPI_SPEED
-  #define LCD_SPI_SPEED SPI_QUARTER_SPEED
-#endif
-
-void u8g_SetPIOutput(u8g_t *u8g, uint8_t pin_index) {
-  if (u8g->pin_list[pin_index]!= U8G_PIN_NONE)
-  pinMode(u8g->pin_list[pin_index],OUTPUT);
-}
-
-void u8g_SetPILevel(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
-  if (u8g->pin_list[pin_index]!= U8G_PIN_NONE)
-  digitalWrite(u8g->pin_list[pin_index],level);
-}
-
-uint8_t u8g_com_samd21_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-
-  static SPISettings lcdSPIConfig;
-
-  switch (msg) {
-    case U8G_COM_MSG_STOP:
-      break;
-
-    case U8G_COM_MSG_INIT:
-      u8g_SetPIOutput(u8g, U8G_PI_CS);
-      u8g_SetPIOutput(u8g, U8G_PI_A0);
-      u8g_SetPIOutput(u8g, U8G_PI_RESET);
-
-      u8g_SetPILevel(u8g, U8G_PI_CS, LOW);
-
-      spiBegin();
-      lcdSPIConfig = SPISettings(900000, MSBFIRST, SPI_MODE0);
-      u8g->pin_list[U8G_PI_A0_STATE] = 0;
-      break;
-
-    case U8G_COM_MSG_ADDRESS:             // define cmd (arg_val = 0) or data mode (arg_val = 1)
-      u8g_SetPILevel(u8g, U8G_PI_A0, arg_val);
-      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:         // arg_val == 1 means chip selected, but ST7920 is active high, so needs inverting
-      u8g_SetPILevel(u8g, U8G_PI_CS, arg_val ? HIGH : LOW);
-      break;
-
-    case U8G_COM_MSG_RESET:
-      u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      SPI.beginTransaction(lcdSPIConfig);
-
-      if (u8g->pin_list[U8G_PI_A0_STATE] == 0) { // command
-        SPI.transfer(0x0f8); u8g->pin_list[U8G_PI_A0_STATE] = 2;
-      }
-      else if (u8g->pin_list[U8G_PI_A0_STATE] == 1) { // data
-        SPI.transfer(0x0fa); u8g->pin_list[U8G_PI_A0_STATE] = 2;
-      }
-
-      SPI.transfer(arg_val & 0x0f0);
-      SPI.transfer(arg_val << 4);
-      SPI.endTransaction();
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ:
-      SPI.beginTransaction(lcdSPIConfig);
-
-      if (u8g->pin_list[U8G_PI_A0_STATE] == 0 ) { // command
-        SPI.transfer(0x0f8); u8g->pin_list[U8G_PI_A0_STATE] = 2;
-      }
-      else if (u8g->pin_list[U8G_PI_A0_STATE] == 1) { // data
-        SPI.transfer(0x0fa); u8g->pin_list[U8G_PI_A0_STATE] = 2;
-      }
-
-      uint8_t *ptr = (uint8_t*)arg_ptr;
-      while (arg_val > 0) {
-        SPI.transfer((*ptr) & 0x0f0);
-        SPI.transfer((*ptr) << 4);
-        ptr++;
-        arg_val--;
-      }
-
-      SPI.endTransaction();
-      break;
-  }
-  return 1;
-}
-
-#endif // __SAMD21__
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -19,10 +18,6 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-
-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
 #ifdef __SAMD51__

 #include "../../inc/MarlinConfig.h"
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 #define CPU_32_BIT

 #include "../shared/Marduino.h"
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -20,10 +19,6 @@
 *
 */

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 /**
 * Hardware and software SPI implementations are included in this file.
 *
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -19,10 +18,6 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-
-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
 #ifdef ADAFRUIT_GRAND_CENTRAL_M4

 /**
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 #include "../../core/serial_hook.h"

 typedef Serial1Class<Uart> UartT;
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 #define SYNC(sc)    while (sc) {  \
                      asm("");    \
                    }
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -20,10 +19,6 @@
 *
 */

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 /**
 * This comes from Arduino library which at the moment is buggy and uncompilable
 */
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 #define _useTimer1
 #define _useTimer2

@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -19,10 +18,6 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-
-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
 #ifdef __SAMD51__

 #include "../../inc/MarlinConfig.h"
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -19,10 +18,6 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-
-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
 #ifdef __SAMD51__

 #include "../../inc/MarlinConfig.h"
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -19,10 +18,6 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-
-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
 #ifdef __SAMD51__

 #include "../../inc/MarlinConfig.h"
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 /**
 * Endstop interrupts for ATMEL SAMD51 based targets.
 *
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 /**
 * Fast IO functions for SAMD51
 */
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -19,11 +18,6 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-#pragma once
-
-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */

 /**
 * Test SAMD51 specific configuration values for errors at compile-time.
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 #define NUMBER_PINS_TOTAL PINS_COUNT

 #define digitalRead_mod(p) extDigitalRead(p)
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 #ifdef ADAFRUIT_GRAND_CENTRAL_M4

 /*
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -19,10 +18,6 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-
-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
 #ifdef __SAMD51__

 // --------------------------------------------------------------------------
@@ -1,9 +1,8 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * 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
@@ -21,10 +20,6 @@
 */
 #pragma once

-/**
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- */
-
 #include <stdint.h>

 // --------------------------------------------------------------------------
@@ -221,7 +221,7 @@ bool PersistentStore::access_finish() {

      return success;

-    #else // !FLASH_EEPROM_LEVELING
+    #else !FLASH_EEPROM_LEVELING

      // The following was written for the STM32F4 but may work with other MCUs as well.
      // Most STM32F4 flash does not allow reading from flash during erase operations.
@@ -48,7 +48,7 @@ static char _ALIGN(4) HAL_eeprom_data[MARLIN_EEPROM_SIZE];
 bool PersistentStore::access_start() {
  if (!card.isMounted()) return false;

-  MediaFile file, root = card.getroot();
+  SdFile file, root = card.getroot();
  if (!file.open(&root, EEPROM_FILENAME, O_RDONLY))
    return true;

@@ -63,7 +63,7 @@ bool PersistentStore::access_start() {
 bool PersistentStore::access_finish() {
  if (!card.isMounted()) return false;

-  MediaFile file, root = card.getroot();
+  SdFile file, root = card.getroot();
  int bytes_written = 0;
  if (file.open(&root, EEPROM_FILENAME, O_CREAT | O_WRITE | O_TRUNC)) {
    bytes_written = file.write(HAL_eeprom_data, MARLIN_EEPROM_SIZE);
@@ -50,62 +50,3 @@
 #if ANY(TFT_COLOR_UI, TFT_LVGL_UI, TFT_CLASSIC_UI) && NOT_TARGET(STM32H7xx, STM32F4xx, STM32F1xx)
  #error "TFT_COLOR_UI, TFT_LVGL_UI and TFT_CLASSIC_UI are currently only supported on STM32H7, STM32F4 and STM32F1 hardware."
 #endif
-
-/**
- * Check for common serial pin conflicts
- */
-#define _CHECK_SERIAL_PIN(N) (( \
-    BTN_EN1 == N || DOGLCD_CS == N || HEATER_BED_PIN == N || FAN_PIN == N || \
-    SDIO_D2_PIN == N || SDIO_D3_PIN == N || SDIO_CK_PIN == N || SDIO_CMD_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)
-  #if CHECK_SERIAL_PIN(TX,1)
-    #error "Serial Port 1 TX IO pins conflict with another pin on the board."
-  #endif
-  #if CHECK_SERIAL_PIN(RX,1)
-    #error "Serial Port 1 RX IO pins conflict with another pin on the board."
-  #endif
-#endif
-#if SERIAL_IN_USE(2)
-  #if CHECK_SERIAL_PIN(TX,2)
-    #error "Serial Port 2 TX IO pins conflict with another pin on the board."
-  #endif
-  #if CHECK_SERIAL_PIN(RX,2)
-    #error "Serial Port 2 RX IO pins conflict with another pin on the board."
-  #endif
-#endif
-#if SERIAL_IN_USE(3)
-  #if CHECK_SERIAL_PIN(TX,3)
-    #error "Serial Port 3 TX IO pins conflict with another pin on the board."
-  #endif
-  #if CHECK_SERIAL_PIN(RX,3)
-    #error "Serial Port 3 RX IO pins conflict with another pin on the board."
-  #endif
-#endif
-#if SERIAL_IN_USE(4)
-  #if CHECK_SERIAL_PIN(TX,4)
-    #error "Serial Port 4 TX IO pins conflict with another pin on the board."
-  #endif
-  #if CHECK_SERIAL_PIN(RX,4)
-    #error "Serial Port 4 RX IO pins conflict with another pin on the board."
-  #endif
-#endif
-#if SERIAL_IN_USE(5)
-  #if CHECK_SERIAL_PIN(TX,5)
-    #error "Serial Port 5 TX IO pins conflict with another pin on the board."
-  #endif
-  #if CHECK_SERIAL_PIN(RX,5)
-    #error "Serial Port 5 RX IO pins conflict with another pin on the board."
-  #endif
-#endif
-#if SERIAL_IN_USE(6)
-  #if CHECK_SERIAL_PIN(TX,6)
-    #error "Serial Port 6 TX IO pins conflict with another pin on the board."
-  #endif
-  #if CHECK_SERIAL_PIN(RX,6)
-    #error "Serial Port 6 RX IO pins conflict with another pin on the board."
-  #endif
-#endif
-#undef CHECK_SERIAL_PIN
-#undef _CHECK_SERIAL_PIN
@@ -286,9 +286,6 @@ void HAL_SD_MspInit(SD_HandleTypeDef *hsd) {

    go_to_transfer_speed();

-    hsd.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_ENABLE;
-    hsd.Init.ClockDiv = 8;
-
    #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3) // go to 4 bit wide mode if pins are defined
      retry_Cnt = retryCnt;
      for (;;) {
@@ -436,10 +433,7 @@ bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
  #else

    uint8_t retries = SDIO_READ_RETRIES;
-    while (retries--) {
-      if (SDIO_ReadWriteBlock_DMA(block, src, nullptr)) return true;
-      delay(10);
-    }
+    while (retries--) if (SDIO_ReadWriteBlock_DMA(block, src, nullptr)) return true;
    return false;

  #endif
@@ -150,9 +150,9 @@ void GT911::read_reg(uint16_t reg, uint8_t reg_len, uint8_t* r_data, uint8_t r_l
  sw_iic.start();
  sw_iic.send_byte(gt911_slave_address + 1);  // Set read mode

-  LOOP_L_N(i, r_len)
+  LOOP_L_N(i, r_len) {
    r_data[i] = sw_iic.read_byte(1);  // Read data from reg
-
+  }
  sw_iic.stop();
 }

@@ -39,18 +39,42 @@ class SW_IIC {
  private:
    uint16_t scl_pin;
    uint16_t sda_pin;
-    void write_scl(bool level) { WRITE(scl_pin, level); }
-    void write_sda(bool level) { WRITE(sda_pin, level); }
-    bool read_sda() { return READ(sda_pin); }
-    void set_sda_out() { SET_OUTPUT(sda_pin); }
-    void set_sda_in() { SET_INPUT_PULLUP(sda_pin); }
-    static void iic_delay(uint8_t t) { delayMicroseconds(t); }
+    void write_scl(bool level)
+    {
+      WRITE(scl_pin, level);
+    }
+    void write_sda(bool level)
+    {
+      WRITE(sda_pin, level);
+    }
+    bool read_sda()
+    {
+      return READ(sda_pin);
+    }
+    void set_sda_out()
+    {
+      SET_OUTPUT(sda_pin);
+    }
+    void set_sda_in()
+    {
+      SET_INPUT_PULLUP(sda_pin);
+    }
+    static void iic_delay(uint8_t t)
+    {
+      delayMicroseconds(t);
+    }

  public:
    SW_IIC(uint16_t sda, uint16_t scl);
    // setSCL/SDA have to be called before begin()
-    void setSCL(uint16_t scl) { scl_pin = scl; }
-    void setSDA(uint16_t sda) { sda_pin = sda; }
+    void setSCL(uint16_t scl)
+    {
+      scl_pin = scl;
+    };
+    void setSDA(uint16_t sda)
+    {
+      sda_pin = sda;
+    };
    void init();                // Initialize the IO port of IIC
    void start();               // Send IIC start signal
    void stop();                // Send IIC stop signal
@@ -148,35 +148,20 @@ uint32_t TFT_FSMC::ReadID(tft_data_t Reg) {

 bool TFT_FSMC::isBusy() {
  #ifdef STM32F1xx
-    #define __IS_DMA_ENABLED(__HANDLE__)      ((__HANDLE__)->Instance->CCR & DMA_CCR_EN)
-    #define __IS_DMA_CONFIGURED(__HANDLE__)   ((__HANDLE__)->Instance->CPAR != 0)
+    volatile bool dmaEnabled = (DMAtx.Instance->CCR & DMA_CCR_EN) != RESET;
  #elif defined(STM32F4xx)
-    #define __IS_DMA_ENABLED(__HANDLE__)      ((__HANDLE__)->Instance->CR & DMA_SxCR_EN)
-    #define __IS_DMA_CONFIGURED(__HANDLE__)   ((__HANDLE__)->Instance->PAR != 0)
+    volatile bool dmaEnabled = DMAtx.Instance->CR & DMA_SxCR_EN;
  #endif
-
-  if (!__IS_DMA_CONFIGURED(&DMAtx)) return false;
-
-  // 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;
-
-  __DSB();
-  Abort();
-  return false;
-}
-
-void TFT_FSMC::Abort() {
-  HAL_DMA_Abort(&DMAtx);  // Abort DMA transfer if any
-  HAL_DMA_DeInit(&DMAtx); // Deconfigure DMA
+  if (dmaEnabled) {
+    if (__HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TC_FLAG_INDEX(&DMAtx)) != 0 || __HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TE_FLAG_INDEX(&DMAtx)) != 0)
+      Abort();
+  }
+  else
+    Abort();
+  return dmaEnabled;
 }

 void TFT_FSMC::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
-  DMAtx.Init.PeriphInc = MemoryIncrease;
-  HAL_DMA_Init(&DMAtx);
-  HAL_DMA_Start(&DMAtx, (uint32_t)Data, (uint32_t)&(LCD->RAM), Count);
-}
-
-void TFT_FSMC::Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
  DMAtx.Init.PeriphInc = MemoryIncrease;
  HAL_DMA_Init(&DMAtx);
  DataTransferBegin();
@@ -41,7 +41,6 @@
 #define DATASIZE_8BIT  SPI_DATASIZE_8BIT
 #define DATASIZE_16BIT SPI_DATASIZE_16BIT
 #define TFT_IO_DRIVER  TFT_FSMC
-#define DMA_MAX_SIZE   0xFFFF

 #define TFT_DATASIZE TERN(TFT_INTERFACE_FSMC_8BIT, DATASIZE_8BIT, DATASIZE_16BIT)
 typedef TERN(TFT_INTERFACE_FSMC_8BIT, uint8_t, uint16_t) tft_data_t;
@@ -60,14 +59,13 @@ class TFT_FSMC {

    static uint32_t ReadID(tft_data_t Reg);
    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);

  public:
    static void Init();
    static uint32_t GetID();
    static bool isBusy();
-    static void Abort();
+    static void Abort() { __HAL_DMA_DISABLE(&DMAtx); }

    static void DataTransferBegin(uint16_t DataWidth = TFT_DATASIZE) {}
    static void DataTransferEnd() {};
@@ -75,14 +73,13 @@ class TFT_FSMC {
    static void WriteData(uint16_t Data) { Transmit(tft_data_t(Data)); }
    static void WriteReg(uint16_t Reg) { LCD->REG = tft_data_t(Reg); __DSB(); }

-    static void WriteSequence_DMA(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_PINC_ENABLE, Data, Count); }
-    static void WriteMultiple_DMA(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_PINC_DISABLE, &Data, Count); }
-
-    static void WriteSequence(uint16_t *Data, uint16_t Count) { Transmit(DMA_PINC_ENABLE, Data, Count); }
+    static void WriteSequence(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_PINC_ENABLE, Data, Count); }
+    static void WriteMultiple(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_PINC_DISABLE, &Data, Count); }
    static void WriteMultiple(uint16_t Color, uint32_t Count) {
+      static uint16_t Data; Data = Color;
      while (Count > 0) {
-        Transmit(DMA_MINC_DISABLE, &Color, Count > DMA_MAX_SIZE ? DMA_MAX_SIZE : Count);
-        Count = Count > DMA_MAX_SIZE ? Count - DMA_MAX_SIZE : 0;
+        TransmitDMA(DMA_MINC_DISABLE, &Data, Count > 0xFFFF ? 0xFFFF : Count);
+        Count = Count > 0xFFFF ? Count - 0xFFFF : 0;
      }
    }
 };
@@ -356,7 +356,7 @@ void TFT_LTDC::WriteReg(uint16_t Reg) {
  reg = Reg;
 }

-void TFT_LTDC::Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
+void TFT_LTDC::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {

  while (x_cur != x_min && Count) {
    Transmit(*Data);
@@ -32,7 +32,6 @@
 #define DATASIZE_8BIT  SPI_DATASIZE_8BIT
 #define DATASIZE_16BIT SPI_DATASIZE_16BIT
 #define TFT_IO_DRIVER  TFT_LTDC
-#define DMA_MAX_SIZE   0xFFFF

 #define TFT_DATASIZE DATASIZE_16BIT
 typedef uint16_t tft_data_t;
@@ -50,7 +49,7 @@ class TFT_LTDC {
    static void DrawRect(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t color);
    static void DrawImage(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t *colors);
    static void Transmit(tft_data_t Data);
-    static void Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
+    static void TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);

  public:
    static void Init();
@@ -64,15 +63,13 @@ class TFT_LTDC {
    static void WriteData(uint16_t Data);
    static void WriteReg(uint16_t Reg);

-    // Non-blocking DMA data transfer is not implemented for LTDC interface
-    inline static void WriteSequence_DMA(uint16_t *Data, uint16_t Count) { WriteSequence(Data, Count); }
-    inline static void WriteMultiple_DMA(uint16_t Color, uint16_t Count) { WriteMultiple(Color, Count); }
-
-    static void WriteSequence(uint16_t *Data, uint16_t Count) { Transmit(DMA_PINC_ENABLE, Data, Count); }
+    static void WriteSequence(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_PINC_ENABLE, Data, Count); }
+    static void WriteMultiple(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_PINC_DISABLE, &Data, Count); }
    static void WriteMultiple(uint16_t Color, uint32_t Count) {
+      static uint16_t Data; Data = Color;
      while (Count > 0) {
-        Transmit(DMA_PINC_DISABLE, &Color, Count > DMA_MAX_SIZE ? DMA_MAX_SIZE : Count);
-        Count = Count > DMA_MAX_SIZE ? Count - DMA_MAX_SIZE : 0;
+        TransmitDMA(DMA_MINC_DISABLE, &Data, Count > 0xFFFF ? 0xFFFF : Count);
+        Count = Count > 0xFFFF ? Count - 0xFFFF : 0;
      }
    }
 };
@@ -160,13 +160,16 @@ uint32_t TFT_SPI::ReadID(uint16_t Reg) {

    for (i = 0; i < 4; i++) {
      #if TFT_MISO_PIN != TFT_MOSI_PIN
-        while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) {}
-        SPIx.Instance->DR = 0;
+        //if (hspi->Init.Direction == SPI_DIRECTION_2LINES) {
+          while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) {}
+          SPIx.Instance->DR = 0;
+        //}
      #endif
      while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_RXNE)) {}
      Data = (Data << 8) | SPIx.Instance->DR;
    }

+    __HAL_SPI_DISABLE(&SPIx);
    DataTransferEnd();

    SPIx.Init.BaudRatePrescaler   = BaudRatePrescaler;
@@ -177,43 +180,35 @@ uint32_t TFT_SPI::ReadID(uint16_t Reg) {

 bool TFT_SPI::isBusy() {
  #ifdef STM32F1xx
-    #define __IS_DMA_ENABLED(__HANDLE__)      ((__HANDLE__)->Instance->CCR & DMA_CCR_EN)
-    #define __IS_DMA_CONFIGURED(__HANDLE__)   ((__HANDLE__)->Instance->CPAR != 0)
+    volatile bool dmaEnabled = (DMAtx.Instance->CCR & DMA_CCR_EN) != RESET;
  #elif defined(STM32F4xx)
-    #define __IS_DMA_ENABLED(__HANDLE__)      ((__HANDLE__)->Instance->CR & DMA_SxCR_EN)
-    #define __IS_DMA_CONFIGURED(__HANDLE__)   ((__HANDLE__)->Instance->PAR != 0)
+    volatile bool dmaEnabled = DMAtx.Instance->CR & DMA_SxCR_EN;
  #endif
-
-  if (!__IS_DMA_CONFIGURED(&DMAtx)) return false;
-
-  if (__HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TE_FLAG_INDEX(&DMAtx))) {
-    // You should not be here - DMA transfer error flag is set
-    // Abort DMA transfer and release SPI
+  if (dmaEnabled) {
+    if (__HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TC_FLAG_INDEX(&DMAtx)) != 0 || __HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TE_FLAG_INDEX(&DMAtx)) != 0)
+      Abort();
  }
-  else {
-    // Check if DMA transfer completed flag is set
-    if (__HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TC_FLAG_INDEX(&DMAtx)) == 0) return true;
-    // Check if SPI transmit butter is empty and SPI is idle
-    if ((!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) || (__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY))) return true;
-  }
-
-  Abort();
-  return false;
+  else
+    Abort();
+  return dmaEnabled;
 }

 void TFT_SPI::Abort() {
-  HAL_DMA_Abort(&DMAtx);  // Abort DMA transfer if any
+  // Wait for any running spi
+  while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) {}
+  while ( __HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY)) {}
+  // First, abort any running dma
+  HAL_DMA_Abort(&DMAtx);
+  // DeInit objects
  HAL_DMA_DeInit(&DMAtx);
-
-  CLEAR_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN);
-
-  DataTransferEnd();      // Stop SPI and deselect CS
+  HAL_SPI_DeInit(&SPIx);
+  // Deselect CS
+  DataTransferEnd();
 }

 void TFT_SPI::Transmit(uint16_t Data) {
-  #if TFT_MISO_PIN == TFT_MOSI_PIN
+  if (TFT_MISO_PIN == TFT_MOSI_PIN)
    SPI_1LINE_TX(&SPIx);
-  #endif

  __HAL_SPI_ENABLE(&SPIx);

@@ -222,31 +217,14 @@ void TFT_SPI::Transmit(uint16_t Data) {
  while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) {}
  while ( __HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY)) {}

-  #if TFT_MISO_PIN != TFT_MOSI_PIN
-    __HAL_SPI_CLEAR_OVRFLAG(&SPIx);   // Clear overrun flag in 2 Lines communication mode because received data is not read
-  #endif
+  if (TFT_MISO_PIN != TFT_MOSI_PIN)
+    __HAL_SPI_CLEAR_OVRFLAG(&SPIx);   // Clear overrun flag in 2 Lines communication mode because received is not read
 }

 void TFT_SPI::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
-  DMAtx.Init.MemInc = MemoryIncrease;
-  HAL_DMA_Init(&DMAtx);
+  // Wait last dma finish, to start another
+  while (isBusy()) { /* nada */ }

-  #if TFT_MISO_PIN == TFT_MOSI_PIN
-    SPI_1LINE_TX(&SPIx);
-  #endif
-
-  DataTransferBegin();
-
-  HAL_DMA_Start(&DMAtx, (uint32_t)Data, (uint32_t)&(SPIx.Instance->DR), Count);
-  __HAL_SPI_ENABLE(&SPIx);
-
-  SET_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN);   // Enable Tx DMA Request
-
-  TERN_(TFT_SHARED_SPI, while (isBusy()));
-}
-
-
-void TFT_SPI::Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
  DMAtx.Init.MemInc = MemoryIncrease;
  HAL_DMA_Init(&DMAtx);

@@ -265,6 +243,7 @@ void TFT_SPI::Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count)
 }

 #if ENABLED(USE_SPI_DMA_TC)
+
  void TFT_SPI::TransmitDMA_IT(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {

    DMAtx.Init.MemInc = MemoryIncrease;
@@ -283,7 +262,8 @@ void TFT_SPI::Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count)
    SET_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN);   // Enable Tx DMA Request
  }

-  extern "C" void DMA2_Stream3_IRQHandler(void) { TFT_SPI::DMA_IRQHandler(); }
+  extern "C" void DMA2_Stream3_IRQHandler(void) { HAL_DMA_IRQHandler(&TFT_SPI::DMAtx); }
+
 #endif

 #endif // HAS_SPI_TFT
@@ -39,47 +39,46 @@
 #define DATASIZE_8BIT  SPI_DATASIZE_8BIT
 #define DATASIZE_16BIT SPI_DATASIZE_16BIT
 #define TFT_IO_DRIVER  TFT_SPI
-#define DMA_MAX_SIZE   0xFFFF

 class TFT_SPI {
 private:
  static SPI_HandleTypeDef SPIx;
-  static DMA_HandleTypeDef DMAtx;
+

  static uint32_t ReadID(uint16_t Reg);
  static void Transmit(uint16_t Data);
-  static void Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
  static void TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
  #if ENABLED(USE_SPI_DMA_TC)
    static void TransmitDMA_IT(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
  #endif

 public:
+  static DMA_HandleTypeDef DMAtx;
+
  static void Init();
  static uint32_t GetID();
  static bool isBusy();
  static void Abort();

  static void DataTransferBegin(uint16_t DataWidth = DATASIZE_16BIT);
-  static void DataTransferEnd() { WRITE(TFT_CS_PIN, HIGH); __HAL_SPI_DISABLE(&SPIx); };
+  static void DataTransferEnd() { WRITE(TFT_CS_PIN, HIGH); };
  static void DataTransferAbort();

  static void WriteData(uint16_t Data) { Transmit(Data); }
  static void WriteReg(uint16_t Reg) { WRITE(TFT_A0_PIN, LOW); Transmit(Reg); WRITE(TFT_A0_PIN, HIGH); }

-  static void WriteSequence_DMA(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_MINC_ENABLE, Data, Count); }
-  static void WriteMultiple_DMA(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_MINC_DISABLE, &Data, Count); }
+  static void WriteSequence(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_MINC_ENABLE, Data, Count); }

  #if ENABLED(USE_SPI_DMA_TC)
    static void WriteSequenceIT(uint16_t *Data, uint16_t Count) { TransmitDMA_IT(DMA_MINC_ENABLE, Data, Count); }
-    inline static void DMA_IRQHandler() { HAL_DMA_IRQHandler(&TFT_SPI::DMAtx); }
  #endif

-  static void WriteSequence(uint16_t *Data, uint16_t Count) { Transmit(DMA_MINC_ENABLE, Data, Count); }
+  static void WriteMultiple(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_MINC_DISABLE, &Data, Count); }
  static void WriteMultiple(uint16_t Color, uint32_t Count) {
+    static uint16_t Data; Data = Color;
    while (Count > 0) {
-      Transmit(DMA_MINC_DISABLE, &Color, Count > DMA_MAX_SIZE ? DMA_MAX_SIZE : Count);
-      Count = Count > DMA_MAX_SIZE ? Count - DMA_MAX_SIZE : 0;
+      TransmitDMA(DMA_MINC_DISABLE, &Data, Count > 0xFFFF ? 0xFFFF : Count);
+      Count = Count > 0xFFFF ? Count - 0xFFFF : 0;
    }
  }
 };
@@ -526,22 +526,23 @@ void SPIClass::onReceive(void(*callback)()) {
  _currentSetting->receiveCallback = callback;
  if (callback) {
    switch (_currentSetting->spi_d->clk_id) {
-      #if BOARD_NR_SPI >= 1
-        case RCC_SPI1:
-          dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi1EventCallback);
-          break;
-      #endif
-      #if BOARD_NR_SPI >= 2
-        case RCC_SPI2:
-          dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi2EventCallback);
-          break;
-      #endif
-      #if BOARD_NR_SPI >= 3
-        case RCC_SPI3:
-          dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi3EventCallback);
-          break;
-      #endif
-      default: ASSERT(0);
+    #if BOARD_NR_SPI >= 1
+    case RCC_SPI1:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi1EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 2
+    case RCC_SPI2:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi2EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 3
+    case RCC_SPI3:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi3EventCallback);
+      break;
+    #endif
+    default:
+      ASSERT(0);
    }
  }
  else {
@@ -553,22 +554,23 @@ void SPIClass::onTransmit(void(*callback)()) {
  _currentSetting->transmitCallback = callback;
  if (callback) {
    switch (_currentSetting->spi_d->clk_id) {
-      #if BOARD_NR_SPI >= 1
-        case RCC_SPI1:
-          dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi1EventCallback);
-          break;
-      #endif
-      #if BOARD_NR_SPI >= 2
-         case RCC_SPI2:
-          dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi2EventCallback);
-          break;
-      #endif
-      #if BOARD_NR_SPI >= 3
-        case RCC_SPI3:
-          dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi3EventCallback);
-          break;
-      #endif
-      default: ASSERT(0);
+    #if BOARD_NR_SPI >= 1
+    case RCC_SPI1:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi1EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 2
+     case RCC_SPI2:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi2EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 3
+    case RCC_SPI3:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi3EventCallback);
+      break;
+    #endif
+    default:
+      ASSERT(0);
    }
  }
  else {
@@ -33,15 +33,6 @@
 #include <stdint.h>
 #include <wirish.h>

-// Number of SPI ports
-#ifdef BOARD_SPI3_SCK_PIN
-  #define BOARD_NR_SPI 3
-#elif defined(BOARD_SPI2_SCK_PIN)
-  #define BOARD_NR_SPI 2
-#elif defined(BOARD_SPI1_SCK_PIN)
-  #define BOARD_NR_SPI 1
-#endif
-
 // SPI_HAS_TRANSACTION means SPI has
 //   - beginTransaction()
 //   - endTransaction()
@@ -47,7 +47,7 @@ static char _ALIGN(4) HAL_eeprom_data[MARLIN_EEPROM_SIZE];
 bool PersistentStore::access_start() {
  if (!card.isMounted()) return false;

-  MediaFile file, root = card.getroot();
+  SdFile file, root = card.getroot();
  if (!file.open(&root, EEPROM_FILENAME, O_RDONLY))
    return true; // false aborts the save

@@ -62,7 +62,7 @@ bool PersistentStore::access_start() {
 bool PersistentStore::access_finish() {
  if (!card.isMounted()) return false;

-  MediaFile file, root = card.getroot();
+  SdFile file, root = card.getroot();
  int bytes_written = 0;
  if (file.open(&root, EEPROM_FILENAME, O_CREAT | O_WRITE | O_TRUNC)) {
    bytes_written = file.write(HAL_eeprom_data, MARLIN_EEPROM_SIZE);
@@ -39,7 +39,7 @@ inline uint8_t timer_and_index_for_pin(const pin_t pin, timer_dev **timer_ptr) {
 void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
  const uint16_t duty = invert ? v_size - v : v;
  if (PWM_PIN(pin)) {
-    timer_dev *timer;
+    timer_dev *timer; UNUSED(timer);
    if (timer_freq[timer_and_index_for_pin(pin, &timer)] == 0)
      set_pwm_frequency(pin, PWM_FREQUENCY);
    const uint8_t channel = PIN_MAP[pin].timer_channel;
@@ -55,7 +55,7 @@ void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v
 void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
  if (!PWM_PIN(pin)) return;                    // Don't proceed if no hardware timer

-  timer_dev *timer;
+  timer_dev *timer; UNUSED(timer);
  timer_freq[timer_and_index_for_pin(pin, &timer)] = f_desired;

  // Protect used timers
@@ -1,31 +1,11 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 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 <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
 /*-----------------------------------------------------------------------
+/ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 / * Copyright (c) 2019 BigTreeTech [https://github.com/bigtreetech]
-/ * Low level disk interface module include file (c) ChaN, 2015
+/ * Low level disk interface module include file   (C)ChaN, 2015
 /-----------------------------------------------------------------------*/

+#pragma once
+
 #define _DISKIO_WRITE   1   /* 1: Enable disk_write function */
 #define _DISKIO_IOCTL   1   /* 1: Enable disk_ioctl function */
 #define _DISKIO_ISDIO   0   /* 1: Enable iSDIO control function */
@@ -215,47 +215,22 @@ uint32_t TFT_FSMC::GetID() {
 }

 bool TFT_FSMC::isBusy() {
-  #define __IS_DMA_CONFIGURED(__DMAx__, __CHx__)   (dma_channel_regs(__DMAx__, __CHx__)->CPAR != 0)
-
-  if (!__IS_DMA_CONFIGURED(FSMC_DMA_DEV, FSMC_DMA_CHANNEL)) return false;
-
-  // Check if DMA transfer error or transfer complete flags are set
-  if ((dma_get_isr_bits(FSMC_DMA_DEV, FSMC_DMA_CHANNEL) & (DMA_ISR_TCIF | DMA_ISR_TEIF)) == 0) return true;
-
-  __DSB();
-  Abort();
  return false;
 }

 void TFT_FSMC::Abort() {
-  dma_channel_reg_map *channel_regs = dma_channel_regs(FSMC_DMA_DEV, FSMC_DMA_CHANNEL);

-  dma_disable(FSMC_DMA_DEV, FSMC_DMA_CHANNEL); // Abort DMA transfer if any
-
-  // Deconfigure DMA
-  channel_regs->CCR   = 0U;
-  channel_regs->CNDTR = 0U;
-  channel_regs->CMAR  = 0U;
-  channel_regs->CPAR  = 0U;
 }

 void TFT_FSMC::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
-  // TODO: HAL STM32 uses DMA2_Channel1 for FSMC on STM32F1
-  dma_setup_transfer(FSMC_DMA_DEV, FSMC_DMA_CHANNEL, Data, DMA_SIZE_16BITS, &LCD->RAM, DMA_SIZE_16BITS, DMA_MEM_2_MEM | MemoryIncrease);
-  dma_set_num_transfers(FSMC_DMA_DEV, FSMC_DMA_CHANNEL, Count);
-  dma_clear_isr_bits(FSMC_DMA_DEV, FSMC_DMA_CHANNEL);
-  dma_enable(FSMC_DMA_DEV, FSMC_DMA_CHANNEL);
-}
-
-void TFT_FSMC::Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
  #if defined(FSMC_DMA_DEV) && defined(FSMC_DMA_CHANNEL)
    dma_setup_transfer(FSMC_DMA_DEV, FSMC_DMA_CHANNEL, Data, DMA_SIZE_16BITS, &LCD->RAM, DMA_SIZE_16BITS, DMA_MEM_2_MEM | MemoryIncrease);
    dma_set_num_transfers(FSMC_DMA_DEV, FSMC_DMA_CHANNEL, Count);
    dma_clear_isr_bits(FSMC_DMA_DEV, FSMC_DMA_CHANNEL);
    dma_enable(FSMC_DMA_DEV, FSMC_DMA_CHANNEL);

-    while ((dma_get_isr_bits(FSMC_DMA_DEV, FSMC_DMA_CHANNEL) & (DMA_CCR_TEIE | DMA_CCR_TCIE)) == 0) {}
-    Abort();
+    while ((dma_get_isr_bits(FSMC_DMA_DEV, FSMC_DMA_CHANNEL) & 0x0A) == 0) {};
+    dma_disable(FSMC_DMA_DEV, FSMC_DMA_CHANNEL);
  #endif
 }

@@ -33,10 +33,6 @@
 #define DATASIZE_8BIT  DMA_SIZE_8BITS
 #define DATASIZE_16BIT DMA_SIZE_16BITS
 #define TFT_IO_DRIVER  TFT_FSMC
-#define DMA_MAX_SIZE   0xFFFF
-
-#define DMA_PINC_ENABLE   DMA_PINC_MODE
-#define DMA_PINC_DISABLE  0

 typedef struct {
  __IO uint16_t REG;
@@ -49,7 +45,6 @@ class TFT_FSMC {

    static uint32_t ReadID(uint16_t Reg);
    static void Transmit(uint16_t Data);
-    static void Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
    static void TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);

  public:
@@ -64,14 +59,13 @@ class TFT_FSMC {
    static void WriteData(uint16_t Data) { Transmit(Data); }
    static void WriteReg(uint16_t Reg);

-    static void WriteSequence_DMA(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_PINC_ENABLE, Data, Count); }
-    static void WriteMultiple_DMA(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_PINC_DISABLE, &Data, Count); }
-
-    static void WriteSequence(uint16_t *Data, uint16_t Count) { Transmit(DMA_PINC_ENABLE, Data, Count); }
+    static void WriteSequence(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_PINC_MODE, Data, Count); }
+    static void WriteMultiple(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_CIRC_MODE, &Data, Count); }
    static void WriteMultiple(uint16_t Color, uint32_t Count) {
+      static uint16_t Data; Data = Color;
      while (Count > 0) {
-        Transmit(DMA_PINC_DISABLE, &Color, Count > DMA_MAX_SIZE ? DMA_MAX_SIZE : Count);
-        Count = Count > DMA_MAX_SIZE ? Count - DMA_MAX_SIZE : 0;
+        TransmitDMA(DMA_CIRC_MODE, &Data, Count > 0xFFFF ? 0xFFFF : Count);
+        Count = Count > 0xFFFF ? Count - 0xFFFF : 0;
      }
    }
 };
@@ -26,7 +26,7 @@

 #include "tft_spi.h"

-SPIClass TFT_SPI::SPIx(TFT_SPI_DEVICE);
+SPIClass TFT_SPI::SPIx(1);

 void TFT_SPI::Init() {
  #if PIN_EXISTS(TFT_RESET)
@@ -46,7 +46,7 @@ void TFT_SPI::Init() {
   * STM32F1 has 3 SPI ports, SPI1 in APB2, SPI2/SPI3 in APB1
   * so the minimum prescale of SPI1 is DIV4, SPI2/SPI3 is DIV2
   */
-  #if TFT_SPI_DEVICE == 1
+  #if SPI_DEVICE == 1
    #define SPI_CLOCK_MAX SPI_CLOCK_DIV4
  #else
    #define SPI_CLOCK_MAX SPI_CLOCK_DIV2
@@ -62,7 +62,7 @@ void TFT_SPI::Init() {
    case SPI_SPEED_6:       clock = SPI_CLOCK_DIV64; break;
    default:                clock = SPI_CLOCK_DIV2;  // Default from the SPI library
  }
-  SPIx.setModule(TFT_SPI_DEVICE);
+  SPIx.setModule(1);
  SPIx.setClockDivider(clock);
  SPIx.setBitOrder(MSBFIRST);
  SPIx.setDataMode(SPI_MODE0);
@@ -71,7 +71,7 @@ void TFT_SPI::Init() {
 void TFT_SPI::DataTransferBegin(uint16_t DataSize) {
  SPIx.setDataSize(DataSize);
  SPIx.begin();
-  WRITE(TFT_CS_PIN, LOW);
+  OUT_WRITE(TFT_CS_PIN, LOW);
 }

 #ifdef TFT_DEFAULT_DRIVER
@@ -113,53 +113,15 @@ uint32_t TFT_SPI::ReadID(uint16_t Reg) {
  #endif
 }

-bool TFT_SPI::isBusy() {
-  #define __IS_DMA_CONFIGURED(__DMAx__, __CHx__)   (dma_channel_regs(__DMAx__, __CHx__)->CPAR != 0)
+bool TFT_SPI::isBusy() { return false; }

-  if (!__IS_DMA_CONFIGURED(DMAx, DMA_CHx)) return false;
-
-  if (dma_get_isr_bits(DMAx, DMA_CHx) & DMA_ISR_TEIF) {
-    // You should not be here - DMA transfer error flag is set
-    // Abort DMA transfer and release SPI
-  }
-  else {
-    // Check if DMA transfer completed flag is set
-    if (!(dma_get_isr_bits(DMAx, DMA_CHx) & DMA_ISR_TCIF)) return true;
-    // Check if SPI TX butter is empty and SPI is idle
-    if (!(SPIdev->regs->SR & SPI_SR_TXE) || (SPIdev->regs->SR & SPI_SR_BSY)) return true;
-  }
-
-  Abort();
-  return false;
-}
-
-void TFT_SPI::Abort() {
-  dma_channel_reg_map *channel_regs = dma_channel_regs(DMAx, DMA_CHx);
-
-  dma_disable(DMAx, DMA_CHx); // Abort DMA transfer if any
-  spi_tx_dma_disable(SPIdev);
-
-  // Deconfigure DMA
-  channel_regs->CCR   = 0U;
-  channel_regs->CNDTR = 0U;
-  channel_regs->CMAR  = 0U;
-  channel_regs->CPAR  = 0U;
-
-  DataTransferEnd();
-}
+void TFT_SPI::Abort() { DataTransferEnd(); }

 void TFT_SPI::Transmit(uint16_t Data) { SPIx.send(Data); }

 void TFT_SPI::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
  DataTransferBegin();
-  SPIx.dmaSendAsync(Data, Count, MemoryIncrease == DMA_MINC_ENABLE);
-
-  TERN_(TFT_SHARED_SPI, while (isBusy()));
-}
-
-void TFT_SPI::Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
-  WRITE(TFT_DC_PIN, HIGH);
-  DataTransferBegin();
+  OUT_WRITE(TFT_DC_PIN, HIGH);
  SPIx.dmaSend(Data, Count, MemoryIncrease == DMA_MINC_ENABLE);
  DataTransferEnd();
 }
@@ -25,27 +25,6 @@

 #include <SPI.h>

-#define IS_SPI(N) (BOARD_NR_SPI >= N && (TFT_SCK_PIN == BOARD_SPI##N##_SCK_PIN) && (TFT_MOSI_PIN == BOARD_SPI##N##_MOSI_PIN) && (TFT_MISO_PIN == BOARD_SPI##N##_MISO_PIN))
-#if IS_SPI(1)
-  #define TFT_SPI_DEVICE  1
-  #define SPIdev          SPI1
-  #define DMAx            DMA1
-  #define DMA_CHx         DMA_CH3
-#elif IS_SPI(2)
-  #define TFT_SPI_DEVICE  2
-  #define SPIdev          SPI2
-  #define DMAx            DMA1
-  #define DMA_CHx         DMA_CH5
-#elif IS_SPI(3)
-  #define TFT_SPI_DEVICE  3
-  #define SPIdev          SPI3
-  #define DMAx            DMA2
-  #define DMA_CHx         DMA_CH2
-#else
-  #error "Invalid TFT SPI configuration."
-#endif
-#undef IS_SPI
-
 #ifndef LCD_READ_ID
  #define LCD_READ_ID 0x04   // Read display identification information (0xD3 on ILI9341)
 #endif
@@ -53,19 +32,17 @@
  #define LCD_READ_ID4 0xD3   // Read display identification information (0xD3 on ILI9341)
 #endif

-#define DATASIZE_8BIT  DATA_SIZE_8BIT
-#define DATASIZE_16BIT DATA_SIZE_16BIT
-#define TFT_IO_DRIVER  TFT_SPI
-#define DMA_MAX_SIZE   0xFFFF
+#define DATASIZE_8BIT    DATA_SIZE_8BIT
+#define DATASIZE_16BIT   DATA_SIZE_16BIT
+#define TFT_IO_DRIVER TFT_SPI

-#define DMA_MINC_ENABLE   DMA_MINC_MODE
-#define DMA_MINC_DISABLE  0
+#define DMA_MINC_ENABLE 1
+#define DMA_MINC_DISABLE 0

 class TFT_SPI {
 private:
  static uint32_t ReadID(uint16_t Reg);
  static void Transmit(uint16_t Data);
-  static void Transmit(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
  static void TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);

 public:
@@ -81,16 +58,15 @@ public:
  static void DataTransferAbort();

  static void WriteData(uint16_t Data) { Transmit(Data); }
-  static void WriteReg(uint16_t Reg) { WRITE(TFT_DC_PIN, LOW); Transmit(Reg); WRITE(TFT_DC_PIN, HIGH); }
+  static void WriteReg(uint16_t Reg) { WRITE(TFT_A0_PIN, LOW); Transmit(Reg); WRITE(TFT_A0_PIN, HIGH); }

-  static void WriteSequence_DMA(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_MINC_ENABLE, Data, Count); }
-  static void WriteMultiple_DMA(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_MINC_DISABLE, &Data, Count); }
-
-  static void WriteSequence(uint16_t *Data, uint16_t Count) { Transmit(DMA_MINC_ENABLE, Data, Count); }
+  static void WriteSequence(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_MINC_ENABLE, Data, Count); }
+  static void WriteMultiple(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_MINC_DISABLE, &Data, Count); }
  static void WriteMultiple(uint16_t Color, uint32_t Count) {
+    static uint16_t Data; Data = Color;
    while (Count > 0) {
-      Transmit(DMA_MINC_DISABLE, &Color, Count > DMA_MAX_SIZE ? DMA_MAX_SIZE : Count);
-      Count = Count > DMA_MAX_SIZE ? Count - DMA_MAX_SIZE : 0;
+      TransmitDMA(DMA_MINC_DISABLE, &Data, Count > 0xFFFF ? 0xFFFF : Count);
+      Count = Count > 0xFFFF ? Count - 0xFFFF : 0;
    }
  }
 };
@@ -50,8 +50,6 @@
  #define HAL_PATH(PATH, NAME) XSTR(PATH/NATIVE_SIM/NAME)
 #elif defined(__SAMD51__)
  #define HAL_PATH(PATH, NAME) XSTR(PATH/SAMD51/NAME)
-#elif defined(__SAMD21__)
-  #define HAL_PATH(PATH, NAME) XSTR(PATH/SAMD21/NAME)
 #else
  #error "Unsupported Platform!"
 #endif
@@ -33,9 +33,8 @@
 void UnwPrintf(const char *format, ...) {
  va_list args;

-  va_start(args, format);
-  vprintf(format, args);
-  va_end(args);
+  va_start( args, format );
+  vprintf(format, args );
 }
 #endif

@@ -83,10 +83,10 @@
 #else
  #include <stdint.h>

-  #if defined(__AVR__) || defined(ARDUINO_ARCH_SAM) || defined(__SAMD51__) || defined(__SAMD21__)
+  #if defined(__AVR__) || defined(ARDUINO_ARCH_SAM) || defined(__SAMD51__)
    // we're good to go
  #else
-    #error "This library only supports boards with an AVR, SAM3X, SAMD21 or SAMD51 processor."
+    #error "This library only supports boards with an AVR, SAM3X or SAMD51 processor."
  #endif

  #define Servo_VERSION           2     // software version of this library
@@ -49,10 +49,8 @@
  #include "../DUE/ServoTimers.h"
 #elif defined(__SAMD51__)
  #include "../SAMD51/ServoTimers.h"
-#elif defined(__SAMD21__)
-  #include "../SAMD21/ServoTimers.h"
 #else
-  #error "This library only supports boards with an AVR, SAM3X, SAMD21 or SAMD51 processor."
+  #error "This library only supports boards with an AVR, SAM3X or SAMD51 processor."
 #endif

 // Macros
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Scott Lahteine	c71d10dd74	use has_* naming	2022-10-21 16:39:33 -05:00
Scott Lahteine	fb927f4a06	use the conditional	2022-10-19 21:09:43 -05:00
InsanityAutomation	d01d1f841a	Fix FTDUI Status Screen Timeout	2022-10-18 17:53:07 -04:00