Only subtract home offsets for machine-centric XY

Use raw positions for G34 probing to honor M206 offsets
2022-07-17 15:18:57 -05:00 · 2022-05-29 18:49:20 -04:00
1972 changed files with 86086 additions and 204858 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"
-}
@@ -4,24 +4,16 @@ root = true
 [{*.patch,syntax_test_*}]
 trim_trailing_whitespace = false

-[{*.c,*.cpp,*.h,*.ino,*.py,Makefile}]
+[{*.c,*.cpp,*.h,*.ino}]
+charset = utf-8
+
+[{*.c,*.cpp,*.h,*.ino,Makefile}]
 trim_trailing_whitespace = true
 insert_final_newline = true
 end_of_line = lf
-
-[{*.c,*.cpp,*.h,*.ino}]
-charset = utf-8
 indent_style = space
 indent_size = 2

-[{Makefile}]
-indent_style = tab
-indent_size = 2
-
-[{*.py}]
-indent_style = space
-indent_size = 4
-
-[{*.conf,*.sublime-project}]
+[{*.py,*.conf,*.sublime-project}]
 indent_style = tab
 indent_size = 4
@@ -14,13 +14,13 @@ body:

        ## Before Reporting a Bug

-        - Read and understand Marlin's [Code of Conduct](https://github.com/MarlinFirmware/Marlin/blob/bugfix-2.1.x/.github/code_of_conduct.md). You are expected to comply with it, including treating everyone with respect.
+        - Read and understand Marlin's [Code of Conduct](https://github.com/MarlinFirmware/Marlin/blob/bugfix-2.0.x/.github/code_of_conduct.md). You are expected to comply with it, including treating everyone with respect.

-        - Test with the [`bugfix-2.1.x` branch](https://github.com/MarlinFirmware/Marlin/archive/bugfix-2.1.x.zip) to see whether the issue still exists.
+        - Test with the [`bugfix-2.0.x` branch](https://github.com/MarlinFirmware/Marlin/archive/bugfix-2.0.x.zip) to see whether the issue still exists.

        ## Instructions

-        Please follow the instructions below. Failure to do so may result in your issue being closed. See [Contributing to Marlin](https://github.com/MarlinFirmware/Marlin/blob/bugfix-2.1.x/.github/contributing.md) for additional guidelines.
+        Please follow the instructions below. Failure to do so may result in your issue being closed. See [Contributing to Marlin](https://github.com/MarlinFirmware/Marlin/blob/bugfix-2.0.x/.github/contributing.md) for additional guidelines.

        1. Provide a good title starting with [BUG].
        2. Fill out all sections of this bug report form.
@@ -28,10 +28,10 @@ body:

  - type: dropdown
    attributes:
-      label: Did you test the latest `bugfix-2.1.x` code?
+      label: Did you test the latest `bugfix-2.0.x` code?
      description: >-
        Always try the latest code to make sure the issue you are reporting is not already fixed. To download
-        the latest code just [click this link](https://github.com/MarlinFirmware/Marlin/archive/bugfix-2.1.x.zip).
+        the latest code just [click this link](https://github.com/MarlinFirmware/Marlin/archive/bugfix-2.0.x.zip).
      options:
        - Yes, and the problem still exists.
        - No, but I will test it now!
@@ -50,8 +50,6 @@ body:
        Describe the bug in this section. Tell us what you were trying to do and what
        happened that you did not expect. Provide a clear and concise description of the
        problem and include as many details as possible.
-
-        When pasting formatted text don't forget to put ` ``` ` (on its own line) before and after to make it readable.
      placeholder: |
        Marlin doesn't work.
    validations:
@@ -100,7 +98,7 @@ body:
  - type: input
    attributes:
      label: Printer model
-      description: Creality Ender-3, Prusa mini, or Kossel Delta?
+      description: Creality Ender 3, Prusa mini, or Kossel Delta?

  - type: input
    attributes:
@@ -151,28 +149,21 @@ body:

  - type: markdown
    attributes:
-      value: |
-        # Attachments
+      value: >-
+        ## Other things to include

-  - type: checkboxes
-    attributes:
-      label: Don't forget to include
-      options:
-        - label: A ZIP file containing your `Configuration.h` and `Configuration_adv.h`.
-          required: true
+        Please also be sure to include these items to help with troubleshooting:

-  - type: markdown
-    attributes:
-      value: |
-        ### Optional items to include:
-        - 'Log output from the host. (`M111 S247` for maximum logging.)'
-        - Images or videos demonstrating the problem, if it helps to make it clear.
-        - A G-Code file that exposes the problem, if not affecting _all_ G-code.
+          * **A ZIP file** containing your `Configuration.h` and `Configuration_adv.h`.
+            (Please don't paste lengthy configuration text here.)
+          * **Log output** from the host. (`M111 S247` for maximum logging.)
+          * **Images or videos** demonstrating the problem, if it helps to make it clear.
+          * **A G-Code file** that exposes the problem, if not affecting _all_ G-code.
+
+        If you've made any other modifications to the firmware, please describe them in detail in the space provided.
+
+        When pasting formatted text into the box below don't forget to put ` ``` ` (on its own line) before and after to make it readable.

  - type: textarea
    attributes:
      label: Additional information & file uploads
-      description: >-
-        If you've made any other modifications to the firmware, please describe them in detail.
-
-        When pasting formatted text don't forget to put ` ``` ` (on its own line) before and after to make it readable.
@@ -17,7 +17,7 @@ body:

        - Read and understand Marlin's [Code of Conduct](https://github.com/MarlinFirmware/Marlin/blob/master/.github/code_of_conduct.md). You are expected to comply with it, including treating everyone with respect.

-        - Check the latest [`bugfix-2.1.x` branch](https://github.com/MarlinFirmware/Marlin/archive/bugfix-2.1.x.zip) to see if the feature already exists.
+        - Check the latest [`bugfix-2.0.x` branch](https://github.com/MarlinFirmware/Marlin/archive/bugfix-2.0.x.zip) to see if the feature already exists.

        - Before you proceed with your request, please consider if it is necessary to make it into a firmware feature, or if it may be better suited for a slicer or host feature.

@@ -34,11 +34,8 @@ This project and everyone participating in it is governed by the [Marlin Code of

 We have a Message Board and a Facebook group where our knowledgable user community can provide helpful advice if you have questions.

- [Marlin Documentation](https://marlinfw.org) - Official Marlin documentation
- Facebook Group ["Marlin Firmware"](https://www.facebook.com/groups/1049718498464482/)
- RepRap.org [Marlin Forum](https://forums.reprap.org/list.php?415)
- Facebook Group ["Marlin Firmware for 3D Printers"](https://www.facebook.com/groups/3Dtechtalk/)
- [Marlin Configuration](https://www.youtube.com/results?search_query=marlin+configuration) on YouTube
+* [Marlin RepRap forum](https://reprap.org/forum/list.php?415)
+* [MarlinFirmware on Facebook](https://www.facebook.com/groups/1049718498464482/)

 If chat is more your speed, you can join the MarlinFirmware Discord server:

@@ -119,7 +116,7 @@ Unsure where to begin contributing to Marlin? You can start by looking through t

 ### Pull Requests

-Pull Requests should always be targeted to working branches (e.g., `bugfix-2.1.x` and/or `bugfix-1.1.x`) and never to release branches (e.g., `2.0.x` and/or `1.1.x`). If this is your first Pull Request, please read our [Guide to Pull Requests](https://marlinfw.org/docs/development/getting_started_pull_requests.html) and Github's [Pull Request](https://help.github.com/articles/creating-a-pull-request/) documentation.
+Pull Requests should always be targeted to working branches (e.g., `bugfix-2.0.x` and/or `bugfix-1.1.x`) and never to release branches (e.g., `2.0.x` and/or `1.1.x`). If this is your first Pull Request, please read our [Guide to Pull Requests](https://marlinfw.org/docs/development/getting_started_pull_requests.html) and Github's [Pull Request](https://help.github.com/articles/creating-a-pull-request/) documentation.

 * Fill in [the required template](pull_request_template.md).
 * Don't include issue numbers in the PR title.
@@ -19,31 +19,11 @@ jobs:
    steps:

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

-    - name: Bump Date (bugfix-2.0.x)
-      run: |
-        # Inline Bump Script
-        if [[ ! "$( git log -1 --pretty=%B )" =~ ^\[cron\] ]]; then
-          DIST=$( date +"%Y-%m-%d" )
-          eval "sed -E -i 's/(#define +STRING_DISTRIBUTION_DATE) .*$/\1 \"$DIST\"/g' Marlin/src/inc/Version.h" && \
-          eval "sed -E -i 's/(#define +STRING_DISTRIBUTION_DATE) .*$/\1 \"$DIST\"/g' Marlin/Version.h" && \
-          git config user.name "${GITHUB_ACTOR}" && \
-          git config user.email "${GITHUB_ACTOR}@users.noreply.github.com" && \
-          git add . && \
-          git commit -m "[cron] Bump distribution date ($DIST)" && \
-          git push
-        fi
-        exit 0
-
-    - name: Check out bugfix-2.1.x
-      uses: actions/checkout@v3
-      with:
-        ref: bugfix-2.1.x
-
-    - name: Bump Date (bugfix-2.1.x)
+    - name: Bump Distribution Date
      run: |
        # Inline Bump Script
        if [[ ! "$( git log -1 --pretty=%B )" =~ ^\[cron\] ]]; then
@@ -12,7 +12,6 @@ on:
    - 1.0.x
    - 1.1.x
    - 2.0.x
-    - 2.1.x

 jobs:
  bad_target:
@@ -27,8 +26,8 @@ jobs:
        comment: >
          Thanks for your contribution! Unfortunately we can't accept PRs directed at release branches. We make patches to the bugfix branches and only later do we push them out as releases.

-          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.
+          Please redo this PR starting with the `bugfix-2.0.x` branch and be careful to target `bugfix-2.0.x` when resubmitting the PR.

-          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.
+          See [this page](http://marlinfw.org/docs/development/getting_started_pull_requests.html) for full instructions.
@@ -31,7 +31,7 @@ jobs:
          - "Needs: Work"

    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
      - name: Remove Labels
        uses: actions-ecosystem/action-remove-labels@v1
        with:
@@ -25,4 +25,4 @@ jobs:
        days-before-close: 10
        stale-issue-label: 'stale-closing-soon'
        exempt-all-assignees: true
-        exempt-issue-labels: 'Bug: Confirmed !,T: Feature Request,Needs: More Data,Needs: Discussion,Needs: Documentation,Needs: Patch,Needs: Work,Needs: Testing,help wanted,no-locking'
+        exempt-issue-labels: 'Bug: Confirmed !,T: Feature Request,Needs: Discussion,Needs: Documentation,Needs: Patch,Needs: Work,Needs: Testing,help wanted,no-locking'
@@ -8,7 +8,7 @@ name: CI
 on:
  pull_request:
    branches:
-    - bugfix-2.1.x
+    - bugfix-2.0.x
    paths-ignore:
    - config/**
    - data/**
@@ -16,7 +16,7 @@ on:
    - '**/*.md'
  push:
    branches:
-    - bugfix-2.1.x
+    - bugfix-2.0.x
    paths-ignore:
    - config/**
    - data/**
@@ -33,110 +33,84 @@ jobs:
    strategy:
      matrix:
        test-platform:
+        # Base Environments

-        # Native
+        - DUE
+        - DUE_archim
+        - esp32
        - linux_native
-
-        # AVR
        - mega2560
-        - mega1280
        - at90usb1286_dfu
+        - teensy31
+        - teensy35
+        - teensy41
+        - SAMD51_grandcentral_m4
+
+        # Extended AVR Environments

-        # AVR Extended
        - FYSETC_F6
-        - melzi_optiboot
+        - mega1280
        - rambo
        - sanguino1284p
        - sanguino644p

-        # SAM3X8E
-        - DUE
-        - DUE_archim
+        # STM32F1 (Maple) Environments

-        # SAMD21
-        - SAMD51_grandcentral_m4
-        - SAMD21_minitronics20
-
-        # ESP32
-        - esp32
-        - mks_tinybee
-
-        # Teensy 2
-        #- at90usb1286_cdc
-
-        # Teensy MK20DX256
-        - teensy31
-
-        # Teensy MK64FX512, MK66FX1M0
-        - teensy35
-
-        # Teensy IMXRT1062DVx6A
-        - teensy41
-
-        # STM32F0
-        - malyan_M300
-        - STM32F070CB_malyan
-        - STM32F070RB_malyan
-
-        # STM32F1
-        - chitu_f103
-        - mks_robin
-        - mks_robin_nano_v1v2
-        - PANDA_PI_V29
-        - STM32F103RC_btt
-        - STM32F103RC_fysetc
-        - STM32F103RE_btt
-        - STM32F103RE_btt_USB
-        - STM32F103RE_creality
-        - STM32F103VE_longer
-        #- mks_robin_mini
-        #- mks_robin_nano_v1_3_f4_usbmod
-        #- mks_robin_nano_v1v2_usbmod
-        #- STM32F103CB_malyan
-        #- STM32F103RC_btt_USB
-        #- STM32F103RE
-
-        # STM32F4
-        - ARMED
-        - BIGTREE_BTT002
-        - BIGTREE_GTR_V1_0
-        - BIGTREE_SKR_PRO
-        - FLYF407ZG
-        - FYSETC_S6
-        - LERDGEK
-        - LERDGEX
-        - mks_robin_pro2
-        - Opulo_Lumen_REV3
-        - rumba32
-        - STM32F401RC_creality
-        - STM32F407VE_black
-        - I3DBEEZ9_V1
-
-        # STM32F7
-        - NUCLEO_F767ZI
-        - REMRAM_V1
-
-        # STM32H7
-        - BTT_SKR_SE_BX
-
-        # STM32F1 (Maple)
-        - jgaurora_a5s_a1_maple
-        - mks_robin_lite_maple
-        - mks_robin_pro_maple
+        #- STM32F103RC_btt_maple
        - STM32F103RC_btt_USB_maple
        - STM32F103RC_fysetc_maple
        - STM32F103RC_meeb_maple
+        - jgaurora_a5s_a1_maple
        - STM32F103VE_longer_maple
-        - STM32F103VE_ZM3E4V2_USB_maple
        #- mks_robin_maple
-        #- mks_robin_nano_v1v2_maple
-        #- STM32F103RC_btt_maple
+        - mks_robin_lite_maple
+        - mks_robin_pro_maple
+        #- mks_robin_nano35_maple
        #- STM32F103RE_creality_maple
+        - STM32F103VE_ZM3E4V2_USB_maple
+
+        # STM32 (ST) Environments
+
+        - STM32F103RC_btt
+        #- STM32F103RC_btt_USB
+        - STM32F103RE_btt
+        - STM32F103RE_btt_USB
+        - STM32F103RE_creality
+        - STM32F401RC_creality
+        - STM32F103VE_longer
+        - STM32F407VE_black
+        - STM32F401VE_STEVAL
+        - BIGTREE_BTT002
+        - BIGTREE_SKR_PRO
+        - BIGTREE_GTR_V1_0
+        - mks_robin
+        - ARMED
+        - FYSETC_S6
+        - STM32F070CB_malyan
+        - STM32F070RB_malyan
+        - malyan_M300
+        - FLYF407ZG
+        - rumba32
+        - LERDGEX
+        - LERDGEK
+        - mks_robin_nano35
+        - NUCLEO_F767ZI
+        - REMRAM_V1
+        - BTT_SKR_SE_BX
+        - chitu_f103
+        - Index_Mobo_Rev03
+
+        # Put lengthy tests last

-        # LPC176x - Lengthy tests
        - LPC1768
        - LPC1769

+        # Non-working environment tests
+        #- at90usb1286_cdc
+        #- STM32F103CB_malyan
+        #- STM32F103RE
+        #- mks_robin_mini
+
    steps:

    - name: Check out the PR
@@ -21,21 +21,35 @@

 # Generated files
 _Version.h
-bdf2u8g.exe
-genpages.exe
+bdf2u8g
 marlin_config.json
 mczip.h
-language*.csv
-out-csv/
-out-language/
 *.gen
 *.sublime-workspace

+#
 # OS
+#
 applet/
 .DS_Store

-# Compiled C++ Object files
+#
+# Misc
+#
+*~
+*.orig
+*.rej
+*.bak
+*.idea
+*.i
+*.ii
+*.swp
+tags
+
+#
+# C++
+#
+# Compiled Object files
 *.slo
 *.lo
 *.o
@@ -66,7 +80,10 @@ applet/
 *.out
 *.app

-# Compiled C Object files
+#
+# C
+#
+# Object files
 *.o
 *.ko
 *.obj
@@ -126,16 +143,13 @@ vc-fileutils.settings
 .vscode/*
 !.vscode/extensions.json

-# Simulation files
+#Simulation
 imgui.ini
 eeprom.dat
 spi_flash.bin
-fs.img

-# CMake
-buildroot/share/cmake/*
+#cmake
 CMakeLists.txt
-!buildroot/share/cmake/CMakeLists.txt
 src/CMakeLists.txt
 CMakeListsPrivate.txt
 build/
@@ -155,16 +169,3 @@ __pycache__

 # IOLogger logs
 *_log.csv
-
-# Misc.
-*~
-*.orig
-*.rej
-*.bak
-*.idea
-*.i
-*.ii
-*.swp
-tags
-*.logs
-*.bak
@@ -1,16 +1,11 @@
-SCRIPTS_DIR := buildroot/share/scripts
-CONTAINER_RT_BIN := docker
-CONTAINER_RT_OPTS := --rm -v $(PWD):/code -v platformio-cache:/root/.platformio
-CONTAINER_IMAGE := marlin-dev
-
 help:
 	@echo "Tasks for local development:"
 	@echo "* tests-single-ci:             Run a single test from inside the CI"
 	@echo "* tests-single-local:          Run a single test locally"
-	@echo "* tests-single-local-docker:   Run a single test locally, using docker"
+	@echo "* tests-single-local-docker:   Run a single test locally, using docker-compose"
 	@echo "* tests-all-local:             Run all tests locally"
-	@echo "* tests-all-local-docker:      Run all tests locally, using docker"
-	@echo "* setup-local-docker:          Build the local docker image"
+	@echo "* tests-all-local-docker:      Run all tests locally, using docker-compose"
+	@echo "* setup-local-docker:          Setup local docker-compose"
 	@echo ""
 	@echo "Options for testing:"
 	@echo "  TEST_TARGET          Set when running tests-single-*, to select the"
@@ -27,33 +22,31 @@ help:

 tests-single-ci:
 	export GIT_RESET_HARD=true
-	$(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) PLATFORMIO_BUILD_FLAGS=-DGITHUB_ACTION
+	$(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET)
 .PHONY: tests-single-ci

 tests-single-local:
 	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local" ; return 1; fi
-	export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
+	export PATH=./buildroot/bin/:./buildroot/tests/:${PATH} \
 	  && export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
 	  && run_tests . $(TEST_TARGET) "$(ONLY_TEST)"
 .PHONY: tests-single-local

 tests-single-local-docker:
 	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local-docker" ; return 1; fi
-	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
-	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
+	docker-compose run --rm marlin $(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
 .PHONY: tests-single-local-docker

 tests-all-local:
-	export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
+	export PATH=./buildroot/bin/:./buildroot/tests/:${PATH} \
 	  && export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
-	  && for TEST_TARGET in $$($(SCRIPTS_DIR)/get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; done
+	  && for TEST_TARGET in $$(./get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; done
 .PHONY: tests-all-local

 tests-all-local-docker:
-	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
-	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
+	docker-compose run --rm marlin $(MAKE) tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
 .PHONY: tests-all-local-docker

 setup-local-docker:
-	$(CONTAINER_RT_BIN) build -t $(CONTAINER_IMAGE) -f docker/Dockerfile .
+	docker-compose build
 .PHONY: setup-local-docker
@@ -63,8 +63,8 @@ HARDWARE_MOTHERBOARD ?= 1020

 ifeq ($(OS),Windows_NT)
  # Windows
-  ARDUINO_INSTALL_DIR ?= ${HOME}/AppData/Local/Arduino
-  ARDUINO_USER_DIR ?= ${HOME}/Documents/Arduino
+  ARDUINO_INSTALL_DIR ?= ${HOME}/Arduino
+  ARDUINO_USER_DIR ?= ${HOME}/Arduino
 else
  UNAME_S := $(shell uname -s)
  ifeq ($(UNAME_S),Linux)
@@ -82,11 +82,11 @@ endif

 # Arduino source install directory, and version number
 # On most linuxes this will be /usr/share/arduino
-ARDUINO_INSTALL_DIR  ?= ${HOME}/AppData/Local/Arduino       # C:/Users/${USERNAME}/AppData/Local/Arduino
-ARDUINO_VERSION      ?= 10819
+ARDUINO_INSTALL_DIR  ?= ${HOME}/Arduino
+ARDUINO_VERSION      ?= 106

 # The installed Libraries are in the User folder
-ARDUINO_USER_DIR ?= ${HOME}/Documents/Arduino
+ARDUINO_USER_DIR ?= ${HOME}/Arduino

 # You can optionally set a path to the avr-gcc tools.
 # Requires a trailing slash. For example, /usr/local/avr-gcc/bin/
@@ -109,7 +109,7 @@ LIQUID_TWI2        ?= 0
 # This defines if Wire is needed
 WIRE               ?= 0

-# This defines if Tone is needed (i.e., SPEAKER is defined in Configuration.h)
+# This defines if Tone is needed (i.e SPEAKER is defined in Configuration.h)
 # Disabling this (and SPEAKER) saves approximately 350 bytes of memory.
 TONE               ?= 1

@@ -307,22 +307,133 @@ 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)
-# Zonestar zrib V5.3 (Chinese RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1163)
-# Pxmalion Core I3
-else ifeq ($(HARDWARE_MOTHERBOARD),1164)
+else ifeq ($(HARDWARE_MOTHERBOARD),1161)
+
+
+# 3Drag Controller
+else ifeq ($(HARDWARE_MOTHERBOARD),1100)
+# Velleman K8200 Controller (derived from 3Drag Controller)
+else ifeq ($(HARDWARE_MOTHERBOARD),1101)
+# Velleman K8400 Controller (derived from 3Drag Controller)
+else ifeq ($(HARDWARE_MOTHERBOARD),1102)
+# Velleman K8600 Controller (Vertex Nano)
+else ifeq ($(HARDWARE_MOTHERBOARD),1103)
+# Velleman K8800 Controller (Vertex Delta)
+else ifeq ($(HARDWARE_MOTHERBOARD),1104)
+# 2PrintBeta BAM&DICE with STK drivers
+else ifeq ($(HARDWARE_MOTHERBOARD),1105)
+# 2PrintBeta BAM&DICE Due with STK drivers
+else ifeq ($(HARDWARE_MOTHERBOARD),1106)
+# MKS BASE v1.0
+else ifeq ($(HARDWARE_MOTHERBOARD),1107)
+# MKS v1.4 with A4982 stepper drivers
+else ifeq ($(HARDWARE_MOTHERBOARD),1108)
+# MKS v1.5 with Allegro A4982 stepper drivers
+else ifeq ($(HARDWARE_MOTHERBOARD),1109)
+# MKS v1.6 with Allegro A4982 stepper drivers
+else ifeq ($(HARDWARE_MOTHERBOARD),1110)
+# MKS BASE 1.0 with Heroic HR4982 stepper drivers
+else ifeq ($(HARDWARE_MOTHERBOARD),1111)
+# MKS GEN v1.3 or 1.4
+else ifeq ($(HARDWARE_MOTHERBOARD),1112)
+# MKS GEN L
+else ifeq ($(HARDWARE_MOTHERBOARD),1113)
+# zrib V2.0 control board (Chinese RAMPS replica)
+else ifeq ($(HARDWARE_MOTHERBOARD),1114)
+# BigTreeTech or BIQU KFB2.0
+else ifeq ($(HARDWARE_MOTHERBOARD),1115)
+# Felix 2.0+ Electronics Board (RAMPS like)
+else ifeq ($(HARDWARE_MOTHERBOARD),1116)
+# Invent-A-Part RigidBoard
+else ifeq ($(HARDWARE_MOTHERBOARD),1117)
+# Invent-A-Part RigidBoard V2
+else ifeq ($(HARDWARE_MOTHERBOARD),1118)
+# Sainsmart 2-in-1 board
+else ifeq ($(HARDWARE_MOTHERBOARD),1119)
+# Ultimaker
+else ifeq ($(HARDWARE_MOTHERBOARD),1120)
+# Ultimaker (Older electronics. Pre 1.5.4. This is rare)
+else ifeq ($(HARDWARE_MOTHERBOARD),1121)
+  MCU              ?= atmega1280
+  PROG_MCU         ?= m1280
+
+# Azteeg X3
+else ifeq ($(HARDWARE_MOTHERBOARD),1122)
+# Azteeg X3 Pro
+else ifeq ($(HARDWARE_MOTHERBOARD),1123)
+# Ultimainboard 2.x (Uses TEMP_SENSOR 20)
+else ifeq ($(HARDWARE_MOTHERBOARD),1124)
+# Rumba
+else ifeq ($(HARDWARE_MOTHERBOARD),1125)
+# Raise3D Rumba
+else ifeq ($(HARDWARE_MOTHERBOARD),1126)
+# Rapide Lite RL200 Rumba
+else ifeq ($(HARDWARE_MOTHERBOARD),1127)
+# Formbot T-Rex 2 Plus
+else ifeq ($(HARDWARE_MOTHERBOARD),1128)
+# Formbot T-Rex 3
+else ifeq ($(HARDWARE_MOTHERBOARD),1129)
+# Formbot Raptor
+else ifeq ($(HARDWARE_MOTHERBOARD),1130)
+# Formbot Raptor 2
+else ifeq ($(HARDWARE_MOTHERBOARD),1131)
+# bq ZUM Mega 3D
+else ifeq ($(HARDWARE_MOTHERBOARD),1132)
+# MakeBoard Mini v2.1.2 is a control board sold by MicroMake
+else ifeq ($(HARDWARE_MOTHERBOARD),1133)
+# TriGorilla Anycubic version 1.3 based on RAMPS EFB
+else ifeq ($(HARDWARE_MOTHERBOARD),1134)
+# TriGorilla Anycubic version 1.4 based on RAMPS EFB
+else ifeq ($(HARDWARE_MOTHERBOARD),1135)
+# TriGorilla Anycubic version 1.4 Rev 1.1
+else ifeq ($(HARDWARE_MOTHERBOARD),1136)
+# Creality: Ender-4, CR-8
+else ifeq ($(HARDWARE_MOTHERBOARD),1137)
+# Creality: CR10S, CR20, CR-X
+else ifeq ($(HARDWARE_MOTHERBOARD),1138)
+# Dagoma F5
+else ifeq ($(HARDWARE_MOTHERBOARD),1139)
+# FYSETC F6 1.3
+else ifeq ($(HARDWARE_MOTHERBOARD),1140)
+# FYSETC F6 1.5
+else ifeq ($(HARDWARE_MOTHERBOARD),1141)
+# Duplicator i3 Plus
+else ifeq ($(HARDWARE_MOTHERBOARD),1142)
+# VORON
+else ifeq ($(HARDWARE_MOTHERBOARD),1143)
+# TRONXY V3 1.0
+else ifeq ($(HARDWARE_MOTHERBOARD),1144)
+# Z-Bolt X Series
+else ifeq ($(HARDWARE_MOTHERBOARD),1145)
+# TT OSCAR
+else ifeq ($(HARDWARE_MOTHERBOARD),1146)
+# Overlord/Overlord Pro
+else ifeq ($(HARDWARE_MOTHERBOARD),1147)
+# ADIMLab Gantry v1
+else ifeq ($(HARDWARE_MOTHERBOARD),1148)
+# ADIMLab Gantry v2
+else ifeq ($(HARDWARE_MOTHERBOARD),1149)
+# BIQU Tango V1
+else ifeq ($(HARDWARE_MOTHERBOARD),1150)
+# MKS GEN L V2
+else ifeq ($(HARDWARE_MOTHERBOARD),1151)
+# MKS GEN L V2.1
+else ifeq ($(HARDWARE_MOTHERBOARD),1152)
+# Copymaster 3D
+else ifeq ($(HARDWARE_MOTHERBOARD),1153)
+# Ortur 4
+else ifeq ($(HARDWARE_MOTHERBOARD),1154)
+# Tenlog D3 Hero
+else ifeq ($(HARDWARE_MOTHERBOARD),1155)

 #
 # RAMBo and derivatives
@@ -401,7 +512,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1324)
 else ifeq ($(HARDWARE_MOTHERBOARD),1325)
 # Intamsys 4.0 (Funmat HT)
 else ifeq ($(HARDWARE_MOTHERBOARD),1326)
-# Malyan M180 Mainboard Version 2 (no display function, direct G-code only)
+# Malyan M180 Mainboard Version 2 (no display function, direct gcode only)
 else ifeq ($(HARDWARE_MOTHERBOARD),1327)
 # Geeetech GT2560 Rev B for A20(M/T/D)
 else ifeq ($(HARDWARE_MOTHERBOARD),1328)
@@ -656,18 +767,18 @@ ifeq ($(HARDWARE_VARIANT), $(filter $(HARDWARE_VARIANT),arduino Teensy Sanguino)
  # Old libraries (avr-core 1.6.21 < / Arduino < 1.6.8)
  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
  # New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/arduino/avr/1.8.6/libraries/SPI/src
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
 endif

 ifeq ($(IS_MCU),1)
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/arduino/avr/1.8.6/cores/arduino
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/cores/arduino

  # Old libraries (avr-core 1.6.21 < / Arduino < 1.6.8)
  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SoftwareSerial
  # New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/arduino/avr/1.8.6/libraries/SPI/src
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/arduino/avr/1.8.6/libraries/SoftwareSerial/src
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SoftwareSerial/src
 endif

 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/LiquidCrystal/src
@@ -681,17 +792,17 @@ ifeq ($(WIRE), 1)
  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire
  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/utility
  # New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/libraries/Wire/src
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/libraries/Wire/src/utility
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/src
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/src/utility
 endif
 ifeq ($(NEOPIXEL), 1)
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Adafruit_NeoPixel
 endif
 ifeq ($(U8GLIB), 1)
-VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib-HAL
-VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib-HAL/src
-# VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib
-# VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/src
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/csrc
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/cppsrc
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/fntsrc
 endif
 ifeq ($(TMC), 1)
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/TMCStepper/src
@@ -700,9 +811,9 @@ endif

 ifeq ($(HARDWARE_VARIANT), arduino)
  HARDWARE_SUB_VARIANT ?= mega
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/variants/$(HARDWARE_SUB_VARIANT)
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/variants/$(HARDWARE_SUB_VARIANT)
 else ifeq ($(HARDWARE_VARIANT), Sanguino)
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/variants/sanguino
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/marlin/avr/variants/sanguino
 else ifeq ($(HARDWARE_VARIANT), archim)
  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/system/libsam
  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/system/CMSIS/CMSIS/Include/
@@ -718,7 +829,7 @@ else ifeq ($(HARDWARE_VARIANT), archim)
  LDLIBS   = $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/variants/archim/libsam_sam3x8e_gcc_rel.a
 else
  HARDWARE_SUB_VARIANT ?= standard
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/variants/$(HARDWARE_SUB_VARIANT)
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/$(HARDWARE_VARIANT)/variants/$(HARDWARE_SUB_VARIANT)
 endif

 LIB_SRC = wiring.c \
@@ -733,7 +844,7 @@ endif

 ifeq ($(HARDWARE_VARIANT), Teensy)
  LIB_SRC = wiring.c
-  VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/teensy/cores/teensy
+  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/teensy/cores/teensy
 endif

 LIB_CXXSRC = WMath.cpp WString.cpp Print.cpp SPI.cpp
@@ -880,7 +991,7 @@ AVRDUDE_WRITE_FLASH = -Uflash:w:$(BUILD_DIR)/$(TARGET).hex:i
 ifeq ($(shell uname -s), Linux)
  AVRDUDE_CONF = /etc/avrdude/avrdude.conf
 else
-  AVRDUDE_CONF = $(ARDUINO_INSTALL_DIR)/packages/arduino/tools/avrdude/6.3.0-arduino17/etc/avrdude.conf
+  AVRDUDE_CONF = $(ARDUINO_INSTALL_DIR)/hardware/tools/avr/etc/avrdude.conf
 endif
 AVRDUDE_FLAGS = -D -C$(AVRDUDE_CONF) \
  -p$(PROG_MCU) -P$(AVRDUDE_PORT) -c$(AVRDUDE_PROGRAMMER) \
@@ -27,7 +27,7 @@ Configuration
  - https://github.com/MarlinFirmware/Configurations
    Example configurations for several printer models.

-  - https://youtu.be/3gwWVFtdg-4
+  - https://www.youtube.com/watch?v=3gwWVFtdg-4
    A good 20-minute overview of Marlin configuration by Tom Sanladerer.
    (Applies to Marlin 1.0.x, so Jerk and Acceleration should be halved.)
    Also... https://www.google.com/search?tbs=vid%3A1&q=configure+marlin
@@ -16,7 +16,7 @@
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
 #pragma once
@@ -28,179 +28,25 @@
 /**
 * Marlin release version identifier
 */
-#define SHORT_BUILD_VERSION "DW7.4.9"
+//#define SHORT_BUILD_VERSION "bugfix-2.0.x"

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

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

 /**
 * The SOURCE_CODE_URL is the location where users will find the Marlin Source
@@ -208,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/CrealityDwin_2.0"
+//#define SOURCE_CODE_URL "github.com/MarlinFirmware/Marlin"

 /**
 * Default generic printer UUID.
@@ -219,12 +65,12 @@
 * The WEBSITE_URL is the location where users can get more information such as
 * documentation about a specific Marlin release.
 */
-#define WEBSITE_URL "https://www.amazon.com/s?k=F1RST+LAYER"
+//#define WEBSITE_URL "marlinfw.org"

 /**
 * Set the vendor info the serial USB interface, if changable
 * Currently only supported by DUE platform
 */
-//#define  USB_DEVICE_VENDOR_ID           0x0000
-//#define  USB_DEVICE_PRODUCT_ID          0x0000
-//#define  USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
+//#define USB_DEVICE_VENDOR_ID           0x0000
+//#define USB_DEVICE_PRODUCT_ID          0x0000
+//#define USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
@@ -1,93 +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_INVERTED
-
-const unsigned char custom_start_bmp[] PROGMEM = {
-  B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,
-  B11111110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,
-  B11111100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
-  B11111100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
-  B11111110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
-  B11111100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000000,B00000001,B11110000,B00111111,
-  B11111110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000000,B00000010,B00001000,B00011111,
-  B11111100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000000,B00000101,B00000100,B00111111,
-  B11111110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000000,B00001010,B00000010,B00011111,
-  B11111100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000000,B00010101,B00000001,B00111111,
-  B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
-  B11111100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000000,B00010100,B00000001,B00111111,
-  B11111110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
-  B11111100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B00010101,B00000001,B00111111,
-  B11111110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101010,B00001010,B00000010,B00011111,
-  B11111100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010001,B00000101,B00000100,B00111111,
-  B11111110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100001,B00000010,B10001000,B00011111,
-  B11111100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010001,B00000001,B11110000,B00111111,
-  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101010,B00000000,B00000000,B00011111,
-  B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00000000,B00000000,B00111111,
-  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
-  B11111100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
-  B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
-  B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
-  B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
-  B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
-  B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
-  B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11100000,B00101110,B11111011,B01111101,B11111011,B11111011,B11001111,B11000001,B11011111,B10111011,B00111110,B11000000,B11100001,B11111110,B00111100,B00011111,
-  B11111101,B11101110,B01111011,B00111001,B11111001,B11110011,B11001111,B10011110,B11011111,B10111011,B00111110,B11011111,B11011110,B11111100,B11011101,B11100111,
-  B11111101,B11101110,B00111011,B10111011,B11111001,B11101011,B11010111,B10111111,B01011111,B10111011,B01011110,B11011111,B11011110,B11111101,B11101101,B11110111,
-  B11111101,B11101110,B10111011,B11010011,B11111010,B11101011,B10110111,B00111111,B11011111,B10111011,B01001110,B11011111,B11011111,B11111111,B11001101,B11110011,
-  B11111101,B11101110,B11011011,B11000111,B11111010,B11101011,B10111011,B01111111,B11000000,B00111011,B01101110,B11000000,B11100011,B11111111,B00011101,B11110011,
-  B11111101,B11101110,B11001011,B11101111,B11111010,B11011011,B10111011,B01111111,B11011111,B10111011,B01100110,B11011111,B11111000,B11111111,B11001101,B11110011,
-  B11111101,B11101110,B11101011,B11101111,B11111011,B01011011,B00000011,B00111111,B01011111,B10111011,B01110110,B11011111,B11111110,B01111111,B11101101,B11110011,
-  B11111101,B11101110,B11110011,B11101111,B11111011,B01011011,B01111001,B10111110,B11011111,B10111011,B01111010,B11011111,B11011110,B01111101,B11101101,B11110111,
-  B11111101,B11101110,B11110011,B11101111,B11111011,B10111010,B11111101,B10011110,B11011111,B10111011,B01111100,B11011111,B11011110,B11111101,B11001101,B11100111,
-  B11111101,B11101110,B11111011,B11101111,B11111011,B10111010,B11111101,B11000001,B11011111,B10111011,B01111110,B11000000,B11100000,B11111110,B00011100,B00011111
-};
@@ -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
@@ -1,207 +0,0 @@
-#
-# Marlin Firmware
-# config.ini - Options to apply before the build
-#
-[config:base]
-ini_use_config                           = none
-
-# Load all config: sections in this file
-;ini_use_config                          = all
-# Load config file relative to Marlin/
-;ini_use_config                          = another.ini
-# Download configurations from GitHub
-;ini_use_config                          = example/Creality/Ender-5 Plus @ bugfix-2.1.x
-# Download configurations from your server
-;ini_use_config                          = https://me.myserver.com/path/to/configs
-# Evaluate config:base and do a config dump
-;ini_use_config                          = base
-;config_export                           = 2
-
-[config:minimal]
-motherboard                              = BOARD_RAMPS_14_EFB
-serial_port                              = 0
-baudrate                                 = 250000
-
-use_watchdog                             = on
-thermal_protection_hotends               = on
-thermal_protection_hysteresis            = 4
-thermal_protection_period                = 40
-
-bufsize                                  = 4
-block_buffer_size                        = 16
-max_cmd_size                             = 96
-
-extruders                                = 1
-temp_sensor_0                            = 1
-
-temp_hysteresis                          = 3
-heater_0_mintemp                         = 5
-heater_0_maxtemp                         = 275
-preheat_1_temp_hotend                    = 180
-
-bang_max                                 = 255
-pidtemp                                  = on
-pid_k1                                   = 0.95
-pid_max                                  = 255
-pid_functional_range                     = 10
-
-default_kp                               = 22.20
-default_ki                               = 1.08
-default_kd                               = 114.00
-
-x_driver_type                            = A4988
-y_driver_type                            = A4988
-z_driver_type                            = A4988
-e0_driver_type                           = A4988
-
-x_bed_size                               = 200
-x_min_pos                                = 0
-x_max_pos                                = X_BED_SIZE
-
-y_bed_size                               = 200
-y_min_pos                                = 0
-y_max_pos                                = Y_BED_SIZE
-
-z_min_pos                                = 0
-z_max_pos                                = 200
-
-x_home_dir                               = -1
-y_home_dir                               = -1
-z_home_dir                               = -1
-
-x_min_endstop_hit_state                  = HIGH
-y_min_endstop_hit_state                  = HIGH
-z_min_endstop_hit_state                  = HIGH
-
-default_axis_steps_per_unit              = { 80, 80, 400, 500 }
-axis_relative_modes                      = { false, false, false, false }
-default_max_feedrate                     = { 300, 300, 5, 25 }
-default_max_acceleration                 = { 3000, 3000, 100, 10000 }
-
-homing_feedrate_mm_m                     = { (50*60), (50*60), (4*60) }
-homing_bump_divisor                      = { 2, 2, 4 }
-
-x_enable_on                              = 0
-y_enable_on                              = 0
-z_enable_on                              = 0
-e_enable_on                              = 0
-
-invert_x_dir                             = false
-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
-
-disable_x                                = off
-disable_y                                = off
-disable_z                                = off
-disable_e                                = off
-
-proportional_font_ratio                  = 1.0
-default_nominal_filament_dia             = 1.75
-
-junction_deviation_mm                    = 0.013
-
-default_acceleration                     = 3000
-default_travel_acceleration              = 3000
-default_retract_acceleration             = 3000
-
-default_minimumfeedrate                  = 0.0
-default_mintravelfeedrate                = 0.0
-
-minimum_planner_speed                    = 0.05
-min_steps_per_segment                    = 6
-default_minsegmenttime                   = 20000
-
-[config:basic]
-bed_overshoot                            = 10
-busy_while_heating                       = on
-default_ejerk                            = 5.0
-default_keepalive_interval               = 2
-default_leveling_fade_height             = 0.0
-disable_other_extruders                  = on
-display_charset_hd44780                  = JAPANESE
-eeprom_boot_silent                       = on
-eeprom_chitchat                          = on
-endstoppullups                           = on
-extrude_maxlength                        = 200
-extrude_mintemp                          = 170
-host_keepalive_feature                   = on
-hotend_overshoot                         = 15
-jd_handle_small_segments                 = on
-lcd_info_screen_style                    = 0
-lcd_language                             = en
-max_bed_power                            = 255
-mesh_inset                               = 0
-min_software_endstops                    = on
-max_software_endstops                    = on
-min_software_endstop_x                   = on
-min_software_endstop_y                   = on
-min_software_endstop_z                   = on
-max_software_endstop_x                   = on
-max_software_endstop_y                   = on
-max_software_endstop_z                   = on
-preheat_1_fan_speed                      = 0
-preheat_1_label                          = "PLA"
-preheat_1_temp_bed                       = 70
-prevent_cold_extrusion                   = on
-prevent_lengthy_extrude                  = on
-printjob_timer_autostart                 = on
-probing_margin                           = 10
-show_bootscreen                          = on
-soft_pwm_scale                           = 0
-string_config_h_author                   = "(none, default config)"
-temp_bed_hysteresis                      = 3
-temp_bed_residency_time                  = 10
-temp_bed_window                          = 1
-temp_residency_time                      = 10
-temp_window                              = 1
-validate_homing_endstops                 = on
-xy_probe_feedrate                        = (133*60)
-z_clearance_between_probes               = 5
-z_clearance_deploy_probe                 = 10
-z_clearance_multi_probe                  = 5
-
-[config:advanced]
-arc_support                              = on
-auto_report_temperatures                 = on
-autotemp                                 = on
-autotemp_oldweight                       = 0.98
-bed_check_interval                       = 5000
-default_stepper_timeout_sec              = 120
-default_volumetric_extruder_limit        = 0.00
-disable_idle_x                           = on
-disable_idle_y                           = on
-disable_idle_z                           = on
-disable_idle_e                           = on
-e0_auto_fan_pin                          = -1
-encoder_100x_steps_per_sec               = 80
-encoder_10x_steps_per_sec                = 30
-encoder_rate_multiplier                  = on
-extended_capabilities_report             = on
-extruder_auto_fan_speed                  = 255
-extruder_auto_fan_temperature            = 50
-fanmux0_pin                              = -1
-fanmux1_pin                              = -1
-fanmux2_pin                              = -1
-faster_gcode_parser                      = on
-homing_bump_mm                           = { 5, 5, 2 }
-max_arc_segment_mm                       = 1.0
-min_arc_segment_mm                       = 0.1
-min_circle_segments                      = 72
-n_arc_correction                         = 25
-serial_overrun_protection                = on
-slowdown                                 = on
-slowdown_divisor                         = 2
-temp_sensor_bed                          = 0
-thermal_protection_bed_hysteresis        = 2
-thermocouple_max_errors                  = 15
-tx_buffer_size                           = 0
-watch_bed_temp_increase                  = 2
-watch_bed_temp_period                    = 60
-watch_temp_increase                      = 2
-watch_temp_period                        = 20
@@ -61,40 +61,23 @@ void save_reset_reason() {
  wdt_disable();
 }

-#include "registers.h"
-
-MarlinHAL::MarlinHAL() {
-  TERN_(HAL_AVR_DIRTY_INIT, _ATmega_resetperipherals()); // Clean-wipe the device state.
-}
-
 void MarlinHAL::init() {
  // Init Servo Pins
+  #define INIT_SERVO(N) OUT_WRITE(SERVO##N##_PIN, LOW)
  #if HAS_SERVO_0
-    OUT_WRITE(SERVO0_PIN, LOW);
+    INIT_SERVO(0);
  #endif
  #if HAS_SERVO_1
-    OUT_WRITE(SERVO1_PIN, LOW);
+    INIT_SERVO(1);
  #endif
  #if HAS_SERVO_2
-    OUT_WRITE(SERVO2_PIN, LOW);
+    INIT_SERVO(2);
  #endif
  #if HAS_SERVO_3
-    OUT_WRITE(SERVO3_PIN, LOW);
+    INIT_SERVO(3);
  #endif

  init_pwm_timers();   // Init user timers to default frequency - 1000HZ
-
-  #if PIN_EXISTS(BEEPER) && ENABLED(HAL_AVR_DIRTY_INIT) && DISABLED(ATMEGA_NO_BEEPFIX)
-    // Make sure no alternative is locked onto the BEEPER.
-    // This fixes the issue where the ATmega is constantly beeping.
-    // Might disable other peripherals using the pin; to circumvent that please undefine one of the above things!
-    // The true culprit is the AVR ArduinoCore that enables peripherals redundantly.
-    // (USART1 on the GeeeTech GT2560)
-    // https://www.youtube.com/watch?v=jMgCvRXkexk
-    _ATmega_savePinAlternate(BEEPER_PIN);
-
-    OUT_WRITE(BEEPER_PIN, LOW);
-  #endif
 }

 void MarlinHAL::reboot() {
@@ -162,12 +145,12 @@ void MarlinHAL::reboot() {
 // Free Memory Accessor
 // ------------------------

-#if HAS_MEDIA
+#if ENABLED(SDSUPPORT)

  #include "../../sd/SdFatUtil.h"
  int freeMemory() { return SdFatUtil::FreeRam(); }

-#else // !HAS_MEDIA
+#else // !SDSUPPORT

  extern "C" {
    extern char __bss_end;
@@ -184,6 +167,6 @@ void MarlinHAL::reboot() {
    }
  }

-#endif // !HAS_MEDIA
+#endif // !SDSUPPORT

 #endif // __AVR__
@@ -32,7 +32,6 @@
  #include <HardwareSerial.h>
 #else
  #include "MarlinSerial.h"
-  #define BOARD_NO_NATIVE_USB
 #endif

 #include <stdint.h>
@@ -107,39 +106,39 @@ 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 || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
+  #if HAS_DGUS_LCD
    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
  #endif
 #endif
@@ -147,8 +146,8 @@ typedef Servo hal_servo_t;
 //
 // ADC
 //
-#define HAL_ADC_VREF_MV   5000
-#define HAL_ADC_RESOLUTION  10
+#define HAL_ADC_VREF        5.0
+#define HAL_ADC_RESOLUTION 10

 //
 // Pin Mapping for M42, M43, M226
@@ -187,7 +186,7 @@ class MarlinHAL {
 public:

  // Earliest possible init, before setup()
-  MarlinHAL();
+  MarlinHAL() {}

  // Watchdog
  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
@@ -198,7 +198,7 @@ void spiBegin() {
    // output pin high - like sending 0xFF
    WRITE(SD_MOSI_PIN, HIGH);

-    for (uint8_t i = 0; i < 8; ++i) {
+    LOOP_L_N(i, 8) {
      WRITE(SD_SCK_PIN, HIGH);

      nop; // adjust so SCK is nice
@@ -225,7 +225,7 @@ void spiBegin() {
  void spiSend(uint8_t data) {
    // no interrupts during byte send - about 8µs
    cli();
-    for (uint8_t i = 0; i < 8; ++i) {
+    LOOP_L_N(i, 8) {
      WRITE(SD_SCK_PIN, LOW);
      WRITE(SD_MOSI_PIN, data & 0x80);
      data <<= 1;
@@ -629,7 +629,7 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
  template class MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> >;
  MSerialLCD lcdSerial(MSerialLCD::HasEmergencyParser);

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

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

  typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialLCD;
@@ -66,26 +66,27 @@ static volatile int8_t Channel[_Nbr_16timers];              // counter for the s

 /************ static functions common to all instances ***********************/

-static inline void handle_interrupts(const timer16_Sequence_t timer, volatile uint16_t* TCNTn, volatile uint16_t* OCRnA) {
-  int8_t cho = Channel[timer];                                        // Handle the prior Channel[timer] first
-  if (cho < 0)                                                        // Channel -1 indicates the refresh interval completed...
-    *TCNTn = 0;                                                       // ...so reset the timer
-  else if (SERVO_INDEX(timer, cho) < ServoCount)                      // prior channel handled?
-    extDigitalWrite(SERVO(timer, cho).Pin.nbr, LOW);                  // pulse the prior channel LOW
+static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t* TCNTn, volatile uint16_t* OCRnA) {
+  if (Channel[timer] < 0)
+    *TCNTn = 0; // channel set to -1 indicated that refresh interval completed so reset the timer
+  else {
+    if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && SERVO(timer, Channel[timer]).Pin.isActive)
+      extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, LOW); // pulse this channel low if activated
+  }

-  Channel[timer] = ++cho;                                             // Handle the next channel (or 0)
-  if (cho < SERVOS_PER_TIMER && SERVO_INDEX(timer, cho) < ServoCount) {
-    *OCRnA = *TCNTn + SERVO(timer, cho).ticks;                        // set compare to current ticks plus duration
-    if (SERVO(timer, cho).Pin.isActive)                               // activated?
-      extDigitalWrite(SERVO(timer, cho).Pin.nbr, HIGH);               // yes: pulse HIGH
+  Channel[timer]++;    // increment to the next channel
+  if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
+    *OCRnA = *TCNTn + SERVO(timer, Channel[timer]).ticks;
+    if (SERVO(timer, Channel[timer]).Pin.isActive)    // check if activated
+      extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, HIGH); // it's an active channel so pulse it high
  }
  else {
    // finished all channels so wait for the refresh period to expire before starting over
-    const unsigned int cval = ((unsigned)*TCNTn) + 32 / (SERVO_TIMER_PRESCALER), // allow 32 cycles to ensure the next OCR1A not missed
-                       ival = (unsigned int)usToTicks(REFRESH_INTERVAL); // at least REFRESH_INTERVAL has elapsed
-    *OCRnA = max(cval, ival);
-
-    Channel[timer] = -1;                                              // reset the timer counter to 0 on the next call
+    if (((unsigned)*TCNTn) + 4 < usToTicks(REFRESH_INTERVAL))    // allow a few ticks to ensure the next OCR1A not missed
+      *OCRnA = (unsigned int)usToTicks(REFRESH_INTERVAL);
+    else
+      *OCRnA = *TCNTn + 4;  // at least REFRESH_INTERVAL has elapsed
+    Channel[timer] = -1; // this will get incremented at the end of the refresh period to start again at the first channel
  }
 }

@@ -122,102 +123,91 @@ static inline void handle_interrupts(const timer16_Sequence_t timer, volatile ui

 /****************** end of static functions ******************************/

-void initISR(const timer16_Sequence_t timer_index) {
-  switch (timer_index) {
-    default: break;
+void initISR(timer16_Sequence_t timer) {
+  #ifdef _useTimer1
+    if (timer == _timer1) {
+      TCCR1A = 0;             // normal counting mode
+      TCCR1B = _BV(CS11);     // set prescaler of 8
+      TCNT1 = 0;              // clear the timer count
+      #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__)
+        SBI(TIFR, OCF1A);      // clear any pending interrupts;
+        SBI(TIMSK, OCIE1A);    // enable the output compare interrupt
+      #else
+        // here if not ATmega8 or ATmega128
+        SBI(TIFR1, OCF1A);     // clear any pending interrupts;
+        SBI(TIMSK1, OCIE1A);   // enable the output compare interrupt
+      #endif
+      #ifdef WIRING
+        timerAttach(TIMER1OUTCOMPAREA_INT, Timer1Service);
+      #endif
+    }
+  #endif

-    #ifdef _useTimer1
-      case _timer1:
-        TCCR1A = 0;             // normal counting mode
-        TCCR1B = _BV(CS11);     // set prescaler of 8
-        TCNT1 = 0;              // clear the timer count
-        #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__)
-          SBI(TIFR, OCF1A);      // clear any pending interrupts;
-          SBI(TIMSK, OCIE1A);    // enable the output compare interrupt
-        #else
-          // here if not ATmega8 or ATmega128
-          SBI(TIFR1, OCF1A);     // clear any pending interrupts;
-          SBI(TIMSK1, OCIE1A);   // enable the output compare interrupt
-        #endif
-        #ifdef WIRING
-          timerAttach(TIMER1OUTCOMPAREA_INT, Timer1Service);
-        #endif
-        break;
-    #endif
+  #ifdef _useTimer3
+    if (timer == _timer3) {
+      TCCR3A = 0;             // normal counting mode
+      TCCR3B = _BV(CS31);     // set prescaler of 8
+      TCNT3 = 0;              // clear the timer count
+      #ifdef __AVR_ATmega128__
+        SBI(TIFR, OCF3A);     // clear any pending interrupts;
+        SBI(ETIMSK, OCIE3A);  // enable the output compare interrupt
+      #else
+        SBI(TIFR3, OCF3A);   // clear any pending interrupts;
+        SBI(TIMSK3, OCIE3A); // enable the output compare interrupt
+      #endif
+      #ifdef WIRING
+        timerAttach(TIMER3OUTCOMPAREA_INT, Timer3Service);  // for Wiring platform only
+      #endif
+    }
+  #endif

-    #ifdef _useTimer3
-      case _timer3:
-        TCCR3A = 0;             // normal counting mode
-        TCCR3B = _BV(CS31);     // set prescaler of 8
-        TCNT3 = 0;              // clear the timer count
-        #ifdef __AVR_ATmega128__
-          SBI(TIFR, OCF3A);     // clear any pending interrupts;
-          SBI(ETIMSK, OCIE3A);  // enable the output compare interrupt
-        #else
-          SBI(TIFR3, OCF3A);   // clear any pending interrupts;
-          SBI(TIMSK3, OCIE3A); // enable the output compare interrupt
-        #endif
-        #ifdef WIRING
-          timerAttach(TIMER3OUTCOMPAREA_INT, Timer3Service);  // for Wiring platform only
-        #endif
-        break;
-    #endif
+  #ifdef _useTimer4
+    if (timer == _timer4) {
+      TCCR4A = 0;             // normal counting mode
+      TCCR4B = _BV(CS41);     // set prescaler of 8
+      TCNT4 = 0;              // clear the timer count
+      TIFR4 = _BV(OCF4A);     // clear any pending interrupts;
+      TIMSK4 = _BV(OCIE4A);   // enable the output compare interrupt
+    }
+  #endif

-    #ifdef _useTimer4
-      case _timer4:
-        TCCR4A = 0;             // normal counting mode
-        TCCR4B = _BV(CS41);     // set prescaler of 8
-        TCNT4 = 0;              // clear the timer count
-        TIFR4 = _BV(OCF4A);     // clear any pending interrupts;
-        TIMSK4 = _BV(OCIE4A);   // enable the output compare interrupt
-        break;
-    #endif
-
-    #ifdef _useTimer5
-      case _timer5:
-        TCCR5A = 0;             // normal counting mode
-        TCCR5B = _BV(CS51);     // set prescaler of 8
-        TCNT5 = 0;              // clear the timer count
-        TIFR5 = _BV(OCF5A);     // clear any pending interrupts;
-        TIMSK5 = _BV(OCIE5A);   // enable the output compare interrupt
-        break;
-    #endif
-  }
+  #ifdef _useTimer5
+    if (timer == _timer5) {
+      TCCR5A = 0;             // normal counting mode
+      TCCR5B = _BV(CS51);     // set prescaler of 8
+      TCNT5 = 0;              // clear the timer count
+      TIFR5 = _BV(OCF5A);     // clear any pending interrupts;
+      TIMSK5 = _BV(OCIE5A);   // enable the output compare interrupt
+    }
+  #endif
 }

-void finISR(const timer16_Sequence_t timer_index) {
+void finISR(timer16_Sequence_t timer) {
  // Disable use of the given timer
  #ifdef WIRING
-    switch (timer_index) {
-      default: break;
-
-      case _timer1:
-        CBI(
-          #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
-            TIMSK1
-          #else
-            TIMSK
-          #endif
-          , OCIE1A    // disable timer 1 output compare interrupt
-        );
-        timerDetach(TIMER1OUTCOMPAREA_INT);
-        break;
-
-      case _timer3:
-        CBI(
-          #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
-            TIMSK3
-          #else
-            ETIMSK
-          #endif
-          , OCIE3A    // disable the timer3 output compare A interrupt
-        );
-        timerDetach(TIMER3OUTCOMPAREA_INT);
-        break;
+    if (timer == _timer1) {
+      CBI(
+        #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
+          TIMSK1
+        #else
+          TIMSK
+        #endif
+          , OCIE1A);    // disable timer 1 output compare interrupt
+      timerDetach(TIMER1OUTCOMPAREA_INT);
+    }
+    else if (timer == _timer3) {
+      CBI(
+        #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
+          TIMSK3
+        #else
+          ETIMSK
+        #endif
+          , OCIE3A);    // disable the timer3 output compare A interrupt
+      timerDetach(TIMER3OUTCOMPAREA_INT);
    }
  #else // !WIRING
    // For arduino - in future: call here to a currently undefined function to reset the timer
-    UNUSED(timer_index);
+    UNUSED(timer);
  #endif
 }

@@ -23,7 +23,7 @@

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

-#if ANY(EEPROM_SETTINGS, SD_FIRMWARE_UPDATE)
+#if EITHER(EEPROM_SETTINGS, SD_FIRMWARE_UPDATE)

 /**
 * PersistentStore for Arduino-style EEPROM interface
@@ -120,7 +120,7 @@ void pciSetup(const int8_t pin) {

 void setup_endstop_interrupts() {
  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
-  #if USE_X_MAX
+  #if HAS_X_MAX
    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(X_MAX_PIN);
    #else
@@ -128,7 +128,7 @@ void setup_endstop_interrupts() {
      pciSetup(X_MAX_PIN);
    #endif
  #endif
-  #if USE_X_MIN
+  #if HAS_X_MIN
    #if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(X_MIN_PIN);
    #else
@@ -136,7 +136,7 @@ void setup_endstop_interrupts() {
      pciSetup(X_MIN_PIN);
    #endif
  #endif
-  #if USE_Y_MAX
+  #if HAS_Y_MAX
    #if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Y_MAX_PIN);
    #else
@@ -144,7 +144,7 @@ void setup_endstop_interrupts() {
      pciSetup(Y_MAX_PIN);
    #endif
  #endif
-  #if USE_Y_MIN
+  #if HAS_Y_MIN
    #if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Y_MIN_PIN);
    #else
@@ -152,7 +152,7 @@ void setup_endstop_interrupts() {
      pciSetup(Y_MIN_PIN);
    #endif
  #endif
-  #if USE_Z_MAX
+  #if HAS_Z_MAX
    #if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z_MAX_PIN);
    #else
@@ -160,7 +160,7 @@ void setup_endstop_interrupts() {
      pciSetup(Z_MAX_PIN);
    #endif
  #endif
-  #if USE_Z_MIN
+  #if HAS_Z_MIN
    #if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z_MIN_PIN);
    #else
@@ -168,97 +168,97 @@ void setup_endstop_interrupts() {
      pciSetup(Z_MIN_PIN);
    #endif
  #endif
-  #if USE_I_MAX
+  #if HAS_I_MAX
    #if (digitalPinToInterrupt(I_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(I_MAX_PIN);
    #else
-      static_assert(digitalPinHasPCICR(I_MAX_PIN), "I_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(I_MAX_PIN), "I_MAX_PIN is not interrupt-capable");
      pciSetup(I_MAX_PIN);
    #endif
-  #elif USE_I_MIN
+  #elif HAS_I_MIN
    #if (digitalPinToInterrupt(I_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(I_MIN_PIN);
    #else
-      static_assert(digitalPinHasPCICR(I_MIN_PIN), "I_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(I_MIN_PIN), "I_MIN_PIN is not interrupt-capable");
      pciSetup(I_MIN_PIN);
    #endif
  #endif
-  #if USE_J_MAX
+  #if HAS_J_MAX
    #if (digitalPinToInterrupt(J_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(J_MAX_PIN);
    #else
-      static_assert(digitalPinHasPCICR(J_MAX_PIN), "J_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(J_MAX_PIN), "J_MAX_PIN is not interrupt-capable");
      pciSetup(J_MAX_PIN);
    #endif
-  #elif USE_J_MIN
+  #elif HAS_J_MIN
    #if (digitalPinToInterrupt(J_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(J_MIN_PIN);
    #else
-      static_assert(digitalPinHasPCICR(J_MIN_PIN), "J_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(J_MIN_PIN), "J_MIN_PIN is not interrupt-capable");
      pciSetup(J_MIN_PIN);
    #endif
  #endif
-  #if USE_K_MAX
+  #if HAS_K_MAX
    #if (digitalPinToInterrupt(K_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(K_MAX_PIN);
    #else
-      static_assert(digitalPinHasPCICR(K_MAX_PIN), "K_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(K_MAX_PIN), "K_MAX_PIN is not interrupt-capable");
      pciSetup(K_MAX_PIN);
    #endif
-  #elif USE_K_MIN
+  #elif HAS_K_MIN
    #if (digitalPinToInterrupt(K_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(K_MIN_PIN);
    #else
-      static_assert(digitalPinHasPCICR(K_MIN_PIN), "K_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(K_MIN_PIN), "K_MIN_PIN is not interrupt-capable");
      pciSetup(K_MIN_PIN);
    #endif
  #endif
-  #if USE_U_MAX
+  #if HAS_U_MAX
    #if (digitalPinToInterrupt(U_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(U_MAX_PIN);
    #else
-      static_assert(digitalPinHasPCICR(U_MAX_PIN), "U_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(U_MAX_PIN), "U_MAX_PIN is not interrupt-capable");
      pciSetup(U_MAX_PIN);
    #endif
-  #elif USE_U_MIN
+  #elif HAS_U_MIN
    #if (digitalPinToInterrupt(U_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(U_MIN_PIN);
    #else
-      static_assert(digitalPinHasPCICR(U_MIN_PIN), "U_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(U_MIN_PIN), "U_MIN_PIN is not interrupt-capable");
      pciSetup(U_MIN_PIN);
    #endif
  #endif
-  #if USE_V_MAX
+  #if HAS_V_MAX
    #if (digitalPinToInterrupt(V_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(V_MAX_PIN);
    #else
-      static_assert(digitalPinHasPCICR(V_MAX_PIN), "V_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(V_MAX_PIN), "V_MAX_PIN is not interrupt-capable");
      pciSetup(V_MAX_PIN);
    #endif
-  #elif USE_V_MIN
+  #elif HAS_V_MIN
    #if (digitalPinToInterrupt(V_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(V_MIN_PIN);
    #else
-      static_assert(digitalPinHasPCICR(V_MIN_PIN), "V_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(V_MIN_PIN), "V_MIN_PIN is not interrupt-capable");
      pciSetup(V_MIN_PIN);
    #endif
  #endif
-  #if USE_W_MAX
+  #if HAS_W_MAX
    #if (digitalPinToInterrupt(W_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(W_MAX_PIN);
    #else
-      static_assert(digitalPinHasPCICR(W_MAX_PIN), "W_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(W_MAX_PIN), "W_MAX_PIN is not interrupt-capable");
      pciSetup(W_MAX_PIN);
    #endif
-  #elif USE_W_MIN
+  #elif HAS_W_MIN
    #if (digitalPinToInterrupt(W_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(W_MIN_PIN);
    #else
-      static_assert(digitalPinHasPCICR(W_MIN_PIN), "W_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(W_MIN_PIN), "W_MIN_PIN is not interrupt-capable");
      pciSetup(W_MIN_PIN);
    #endif
  #endif
-  #if USE_X2_MAX
+  #if HAS_X2_MAX
    #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(X2_MAX_PIN);
    #else
@@ -266,7 +266,7 @@ void setup_endstop_interrupts() {
      pciSetup(X2_MAX_PIN);
    #endif
  #endif
-  #if USE_X2_MIN
+  #if HAS_X2_MIN
    #if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(X2_MIN_PIN);
    #else
@@ -274,7 +274,7 @@ void setup_endstop_interrupts() {
      pciSetup(X2_MIN_PIN);
    #endif
  #endif
-  #if USE_Y2_MAX
+  #if HAS_Y2_MAX
    #if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Y2_MAX_PIN);
    #else
@@ -282,7 +282,7 @@ void setup_endstop_interrupts() {
      pciSetup(Y2_MAX_PIN);
    #endif
  #endif
-  #if USE_Y2_MIN
+  #if HAS_Y2_MIN
    #if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Y2_MIN_PIN);
    #else
@@ -290,7 +290,7 @@ void setup_endstop_interrupts() {
      pciSetup(Y2_MIN_PIN);
    #endif
  #endif
-  #if USE_Z2_MAX
+  #if HAS_Z2_MAX
    #if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z2_MAX_PIN);
    #else
@@ -298,7 +298,7 @@ void setup_endstop_interrupts() {
      pciSetup(Z2_MAX_PIN);
    #endif
  #endif
-  #if USE_Z2_MIN
+  #if HAS_Z2_MIN
    #if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z2_MIN_PIN);
    #else
@@ -306,7 +306,7 @@ void setup_endstop_interrupts() {
      pciSetup(Z2_MIN_PIN);
    #endif
  #endif
-  #if USE_Z3_MAX
+  #if HAS_Z3_MAX
    #if (digitalPinToInterrupt(Z3_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z3_MAX_PIN);
    #else
@@ -314,7 +314,7 @@ void setup_endstop_interrupts() {
      pciSetup(Z3_MAX_PIN);
    #endif
  #endif
-  #if USE_Z3_MIN
+  #if HAS_Z3_MIN
    #if (digitalPinToInterrupt(Z3_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z3_MIN_PIN);
    #else
@@ -322,7 +322,7 @@ void setup_endstop_interrupts() {
      pciSetup(Z3_MIN_PIN);
    #endif
  #endif
-  #if USE_Z4_MAX
+  #if HAS_Z4_MAX
    #if (digitalPinToInterrupt(Z4_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z4_MAX_PIN);
    #else
@@ -330,7 +330,7 @@ void setup_endstop_interrupts() {
      pciSetup(Z4_MAX_PIN);
    #endif
  #endif
-  #if USE_Z4_MIN
+  #if HAS_Z4_MIN
    #if (digitalPinToInterrupt(Z4_MIN_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z4_MIN_PIN);
    #else
@@ -338,7 +338,7 @@ void setup_endstop_interrupts() {
      pciSetup(Z4_MIN_PIN);
    #endif
  #endif
-  #if USE_Z_MIN_PROBE
+  #if HAS_Z_MIN_PROBE_PIN
    #if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(Z_MIN_PROBE_PIN);
    #else
@@ -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)");
-    for (uint8_t i = 0; i < COUNT(prescaler); ++i) {          // Loop through all prescaler values
-      const uint32_t p = prescaler[i];                        // Extend to 32 bits for calculations
-      DEBUG_ECHOLNPGM("prescaler[", i, "]=", p);
+    LOOP_L_N(i, COUNT(prescaler)) {                           // Loop through all prescaler values
+      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);
@@ -232,7 +215,7 @@ void MarlinHAL::init_pwm_timers() {
    #endif
  };

-  for (uint8_t i = 0; i < COUNT(pwm_pin); ++i)
+  LOOP_L_N(i, COUNT(pwm_pin))
    set_pwm_frequency(pwm_pin[i], 1000);
 }

@@ -255,6 +255,84 @@ enum ClockSource2 : uint8_t {
 #define SET_FOCB(T,V) SET_FOC(T,B,V)
 #define SET_FOCC(T,V) SET_FOC(T,C,V)

+#if 0
+
+/**
+ * PWM availability macros
+ */
+
+// Determine which hardware PWMs are already in use
+#define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN || P == COOLER_AUTO_FAN_PIN)
+#if PIN_EXISTS(CONTROLLER_FAN)
+  #define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)
+#else
+  #define PWM_CHK_FAN_B(P) _PWM_CHK_FAN_B(P)
+#endif
+
+#if ANY_PIN(FAN, FAN1, FAN2, FAN3, FAN4, FAN5, FAN6, FAN7)
+  #if PIN_EXISTS(FAN7)
+    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN || P == FAN6_PIN || P == FAN7_PIN)
+  #elif PIN_EXISTS(FAN6)
+    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN || P == FAN6_PIN)
+  #elif PIN_EXISTS(FAN5)
+    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN)
+  #elif PIN_EXISTS(FAN4)
+    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN)
+  #elif PIN_EXISTS(FAN3)
+    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN)
+  #elif PIN_EXISTS(FAN2)
+    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN)
+  #elif PIN_EXISTS(FAN1)
+    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN)
+  #else
+    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN)
+  #endif
+#else
+  #define PWM_CHK_FAN_A(P) false
+#endif
+
+#if HAS_MOTOR_CURRENT_PWM
+  #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
+    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || 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 || P == MOTOR_CURRENT_PWM_Z)
+  #else
+    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E)
+  #endif
+#else
+  #define PWM_CHK_MOTOR_CURRENT(P) false
+#endif
+
+#ifdef NUM_SERVOS
+  #if AVR_ATmega2560_FAMILY
+    #define PWM_CHK_SERVO(P) (P == 5 || (NUM_SERVOS > 12 && P == 6) || (NUM_SERVOS > 24 && P == 46))  // PWMS 3A, 4A & 5A
+  #elif AVR_ATmega2561_FAMILY
+    #define PWM_CHK_SERVO(P)   (P == 5)  // PWM3A
+  #elif AVR_ATmega1284_FAMILY
+    #define PWM_CHK_SERVO(P)   false
+  #elif AVR_AT90USB1286_FAMILY
+    #define PWM_CHK_SERVO(P)   (P == 16) // PWM3A
+  #elif AVR_ATmega328_FAMILY
+    #define PWM_CHK_SERVO(P)   false
+  #endif
+#else
+  #define PWM_CHK_SERVO(P) false
+#endif
+
+#if ENABLED(BARICUDA)
+  #if HAS_HEATER_1 && HAS_HEATER_2
+    #define PWM_CHK_HEATER(P) (P == HEATER_1_PIN || P == HEATER_2_PIN)
+  #elif HAS_HEATER_1
+    #define PWM_CHK_HEATER(P) (P == HEATER_1_PIN)
+  #endif
+#else
+    #define PWM_CHK_HEATER(P) false
+#endif
+
+#define PWM_CHK(P) (PWM_CHK_HEATER(P) || PWM_CHK_SERVO(P) || PWM_CHK_MOTOR_CURRENT(P) || PWM_CHK_FAN_A(P) || PWM_CHK_FAN_B(P))
+
+#endif // PWM_CHK is not used in Marlin
+
 // define which hardware PWMs are available for the current CPU
 // all timer 1 PWMS deleted from this list because they are never available
 #if AVR_ATmega2560_FAMILY
@@ -27,44 +27,43 @@
 *   Hardware Pin  : 02 03 06 07 01 05 15 16 17 18 23 24 25 26 64 63 13 12 46 45 44 43 78 77 76 75 74 73 72 71 60 59 58 57 56 55 54 53 50 70 52 51 42 41 40 39 38 37 36 35 22 21 20 19 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 | 04 08 09 10 11 14 27 28 29 30 31 32 33 34 47 48 49 61 62 65 66 67 68 69 79 80 81 98 99 100
 *   Port          : E0 E1 E4 E5 G5 E3 H3 H4 H5 H6 B4 B5 B6 B7 J1 J0 H1 H0 D3 D2 D1 D0 A0 A1 A2 A3 A4 A5 A6 A7 C7 C6 C5 C4 C3 C2 C1 C0 D7 G2 G1 G0 L7 L6 L5 L4 L3 L2 L1 L0 B3 B2 B1 B0 F0 F1 F2 F3 F4 F5 F6 F7 K0 K1 K2 K3 K4 K5 K6 K7 | E2 E6 E7 xx xx H2 H7 G3 G4 xx xx xx xx xx D4 D5 D6 xx xx J2 J3 J4 J5 J6 J7 xx xx xx xx xx
 *   Logical Pin   : 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 78 79 80 xx xx 84 85 71 70 xx xx xx xx xx 81 82 83 xx xx 72 73 75 76 77 74 xx xx xx xx xx
- *   Analog Input  :                                                                                                                                                                    0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 #include "../fastio.h"

+// change for your board
+#define DEBUG_LED   DIO21
+
 // UART
-#define RXD         0
-#define TXD         1
+#define RXD         DIO0
+#define TXD         DIO1

 // SPI
-#define MISO        50
-#define MOSI        51
-#define SCK         52
-#define SS          53
+#define SCK         DIO52
+#define MISO        DIO50
+#define MOSI        DIO51
+#define SS          DIO53

 // TWI (I2C)
-#define SCL         21
-#define SDA         20
+#define SCL         DIO21
+#define SDA         DIO20

 // Timers and PWM
-#define OC0A        13
-#define OC0B        4
-#define OC1A        11
-#define OC1B        12
-#define OC2A        10
-#define OC2B        9
-#define OC3A        5
-#define OC3B        2
-#define OC3C        3
-#define OC4A        6
-#define OC4B        7
-#define OC4C        8
-#define OC5A        46
-#define OC5B        45
-#define OC5C        44
+#define OC0A        DIO13
+#define OC0B        DIO4
+#define OC1A        DIO11
+#define OC1B        DIO12
+#define OC2A        DIO10
+#define OC2B        DIO9
+#define OC3A        DIO5
+#define OC3B        DIO2
+#define OC3C        DIO3
+#define OC4A        DIO6
+#define OC4B        DIO7
+#define OC4C        DIO8
+#define OC5A        DIO46
+#define OC5B        DIO45
+#define OC5C        DIO44

 // Digital I/O

@@ -26,36 +26,36 @@
 *
 *   Logical Pin: 38 39 40 41 42 43 44 45 16 10 11 12 06 07 08 09 30 31 32 33 34 35 36 37 17 18 19 20 21 22 23 24 00 01 13 05 02 03 14 15 46 47 48 49 50 51 52 53 25 26 27 28 29 04
 *   Port:        A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7 G0 G1 G2 G3 G4 G5
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 #include "../fastio.h"

+// change for your board
+#define DEBUG_LED   DIO46
+
 // UART
-#define RXD         0
-#define TXD         1
+#define RXD         DIO0
+#define TXD         DIO1

 // SPI
-#define SCK         10
-#define MISO        12
-#define MOSI        11
-#define SS          16
+#define SCK         DIO10
+#define MISO        DIO12
+#define MOSI        DIO11
+#define SS          DIO16

 // TWI (I2C)
-#define SCL         17
-#define SDA         18
+#define SCL         DIO17
+#define SDA         DIO18

 // Timers and PWM
-#define OC0A        9
-#define OC0B        4
-#define OC1A        7
-#define OC1B        8
-#define OC2A        6
-#define OC3A        5
-#define OC3B        2
-#define OC3C        3
+#define OC0A        DIO9
+#define OC0B        DIO4
+#define OC1A        DIO7
+#define OC1B        DIO8
+#define OC2A        DIO6
+#define OC3A        DIO5
+#define OC3B        DIO2
+#define OC3C        DIO3

 // Digital I/O

@@ -26,34 +26,33 @@
 *
 *   Logical Pin: 08 09 10 11 12 13 14 15 16 17 18 19 20 21 00 01 02 03 04 05 06 07
 *   Port:        B0 B1 B2 B3 B4 B5 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 #include "../fastio.h"

+#define DEBUG_LED   AIO5
+
 // UART
-#define RXD         0
-#define TXD         1
+#define RXD         DIO0
+#define TXD         DIO1

 // SPI
-#define SS          10
-#define MOSI        11
-#define MISO        12
-#define SCK         13
+#define SCK         DIO13
+#define MISO        DIO12
+#define MOSI        DIO11
+#define SS          DIO10

 // TWI (I2C)
 #define SCL         AIO5
 #define SDA         AIO4

 // Timers and PWM
-#define OC0A        6
-#define OC0B        5
-#define OC1A        9
-#define OC1B        10
-#define OC2A        11
-#define OC2B        3
+#define OC0A        DIO6
+#define OC0B        DIO5
+#define OC1A        DIO9
+#define OC1B        DIO10
+#define OC2A        DIO11
+#define OC2B        DIO3

 // Digital I/O

@@ -26,9 +26,6 @@
 *
 *   Logical Pin: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *   Port:        B0 B1 B2 B3 B4 B5 B6 B7 D0 D1 D2 D3 D4 D5 D6 D7 C0 C1 C2 C3 C4 C5 C6 C7 A7 A6 A5 A4 A3 A2 A1 A0
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 /**                        ATMega644
@@ -59,32 +56,34 @@

 #include "../fastio.h"

-// UART
-#define RXD         8
-#define TXD         9
-#define RXD0        8
-#define TXD0        9
+#define DEBUG_LED   DIO0

-#define RXD1        10
-#define TXD1        11
+// UART
+#define RXD         DIO8
+#define TXD         DIO9
+#define RXD0        DIO8
+#define TXD0        DIO9
+
+#define RXD1        DIO10
+#define TXD1        DIO11

 // SPI
-#define SS          4
-#define MOSI        5
-#define MISO        6
-#define SCK         7
+#define SCK         DIO7
+#define MISO        DIO6
+#define MOSI        DIO5
+#define SS          DIO4

 // TWI (I2C)
-#define SCL         16
-#define SDA         17
+#define SCL         DIO16
+#define SDA         DIO17

 // Timers and PWM
-#define OC0A        3
-#define OC0B        4
-#define OC1A        13
-#define OC1B        12
-#define OC2A        15
-#define OC2B        14
+#define OC0A        DIO3
+#define OC0B        DIO4
+#define OC1A        DIO13
+#define OC1B        DIO12
+#define OC2A        DIO15
+#define OC2B        DIO14

 // Digital I/O

@@ -27,18 +27,18 @@
 *   Logical Pin: 28 29 30 31 32 33 34 35 20 21 22 23 24 25 26 27 10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07 08 09(46*47)36 37 18 19 38 39 40 41 42 43 44 45
 *   Port:        A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7
 *            The logical pins 46 and 47 are not supported by Teensyduino, but are supported below as E2 and E3
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 #include "../fastio.h"

+// change for your board
+#define DEBUG_LED   DIO31 /* led D5 red */
+
 // SPI
-#define SS          20  //  8
-#define SCK         21  //  9
-#define MOSI        22  // 10
-#define MISO        23  // 11
+#define SCK         DIO21  //  9
+#define MISO        DIO23  // 11
+#define MOSI        DIO22  // 10
+#define SS          DIO20  //  8

 // Digital I/O

@@ -20,3 +20,7 @@
 *
 */
 #pragma once
+
+#if HAS_SPI_TFT || HAS_FSMC_TFT
+  #error "Sorry! TFT displays are not available for HAL/AVR."
+#endif
@@ -25,40 +25,26 @@
 * Test AVR-specific configuration values for errors at compile-time.
 */

-#if HAS_SPI_TFT || HAS_FSMC_TFT
-  #error "Sorry! TFT displays are not available for HAL/AVR."
-#endif
-
 /**
 * Check for common serial pin conflicts
 */
 #define CHECK_SERIAL_PIN(N) ( \
-     X_STOP_PIN == N || Y_STOP_PIN == N || Z_STOP_PIN  == N \
-  || X_MIN_PIN  == N || Y_MIN_PIN  == N || Z_MIN_PIN   == N \
-  || X_MAX_PIN  == N || Y_MAX_PIN  == N || Z_MAX_PIN   == N \
-  || X_STEP_PIN == N || Y_STEP_PIN == N || Z_STEP_PIN  == N \
-  || X_DIR_PIN  == N || Y_DIR_PIN  == N || Z_DIR_PIN   == N \
-  || X_ENA_PIN  == N || Y_ENA_PIN  == N || Z_ENA_PIN   == N \
-  || BTN_EN1    == N || BTN_EN2    == N || LCD_PINS_EN == N \
+     X_STOP_PIN == N || Y_STOP_PIN == N || Z_STOP_PIN == N \
+  || X_MIN_PIN  == N || Y_MIN_PIN  == N || Z_MIN_PIN  == N \
+  || X_MAX_PIN  == N || Y_MAX_PIN  == N || Z_MAX_PIN  == N \
+  || X_STEP_PIN == N || Y_STEP_PIN == N || Z_STEP_PIN == N \
+  || X_DIR_PIN  == N || Y_DIR_PIN  == N || Z_DIR_PIN  == N \
+  || X_ENA_PIN  == N || Y_ENA_PIN  == N || Z_ENA_PIN  == N \
 )
-#if SERIAL_IN_USE(0)
-  // D0-D1. No known conflicts.
+#if CONF_SERIAL_IS(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
-  #endif
+#if CONF_SERIAL_IS(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
-#if SERIAL_IN_USE(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
+#if CONF_SERIAL_IS(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
  #error "Serial Port 2 pin D16 and/or D17 conflicts with another pin on the board."
 #endif
-#if SERIAL_IN_USE(3) && (CHECK_SERIAL_PIN(14) || CHECK_SERIAL_PIN(15))
+#if CONF_SERIAL_IS(3) && (CHECK_SERIAL_PIN(14) || CHECK_SERIAL_PIN(15))
  #error "Serial Port 3 pin D14 and/or D15 conflicts with another pin on the board."
 #endif
 #undef CHECK_SERIAL_PIN
@@ -73,8 +59,8 @@
 /**
 * Checks for SOFT PWM
 */
-#if HAS_FAN0 && FAN0_PIN == 9 && DISABLED(FAN_SOFT_PWM) && ENABLED(SPEAKER)
-  #error "FAN0_PIN 9 Hardware PWM uses Timer 2 which conflicts with Arduino AVR Tone Timer (for SPEAKER)."
+#if HAS_FAN0 && FAN_PIN == 9 && DISABLED(FAN_SOFT_PWM) && ENABLED(SPEAKER)
+  #error "FAN_PIN 9 Hardware PWM uses Timer 2 which conflicts with Arduino AVR Tone Timer (for SPEAKER)."
  #error "Disable SPEAKER or enable FAN_SOFT_PWM."
 #endif

@@ -95,11 +81,11 @@
 /**
 * The Trinamic library includes SoftwareSerial.h, leading to a compile error.
 */
-#if ALL(HAS_TRINAMIC_CONFIG, ENDSTOP_INTERRUPTS_FEATURE)
+#if BOTH(HAS_TRINAMIC_CONFIG, ENDSTOP_INTERRUPTS_FEATURE)
  #error "TMCStepper includes SoftwareSerial.h which is incompatible with ENDSTOP_INTERRUPTS_FEATURE. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
 #endif

-#if ALL(HAS_TMC_SW_SERIAL, MONITOR_DRIVER_STATUS)
+#if BOTH(HAS_TMC_SW_SERIAL, MONITOR_DRIVER_STATUS)
  #error "MONITOR_DRIVER_STATUS causes performance issues when used with SoftwareSerial-connected drivers. Disable MONITOR_DRIVER_STATUS or use hardware serial to continue."
 #endif

@@ -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,26 +85,29 @@ FORCE_INLINE static uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2
  return intRes;
 }

-// charRes = charIn1 * charIn2 >> 8
+// intRes = intIn1 * intIn2 >> 16
 // uses:
-// r1, r0 for the result of mul. After the mul, r0 holds bits 0-7 of the 16 bit result,
-//        and the top bit of r0 is used for rounding.
-// [charRes] is bits 8-15 and is the returned value.
-// [charIn1] is an 8 bit parameter.
-// [charIn2] is an 8 bit parameter.
-//
-FORCE_INLINE static uint8_t MultiU8X8toH8(uint8_t charIn1, uint8_t charIn2) {
-  uint8_t charRes;
+// 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__ (
-    A("mul %[charIn1], %[charIn2]")
-    A("mov %[charRes], r1")
+    A("clr %[tmp]")
+    A("mul %[charIn1], %B[intIn2]")
+    A("movw %A[intRes], r0")
+    A("mul %[charIn1], %A[intIn2]")
+    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")
-    A("lsl r0")
-    A("adc %[charRes], r1")
-      : [charRes] "=&r" (charRes)
+      : [intRes] "=&r" (intRes),
+        [tmp] "=&r" (tmp)
      : [charIn1] "d" (charIn1),
-        [charIn2] "d" (charIn2)
+        [intIn2] "d" (intIn2)
      : "cc"
  );
-  return charRes;
+  return intRes;
 }
@@ -64,25 +64,23 @@

 #define VALID_PIN(pin) (pin >= 0 && pin < NUM_DIGITAL_PINS ? 1 : 0)
 #if AVR_ATmega1284_FAMILY
-  #define IS_ANALOG(P) WITHIN(P, analogInputToDigitalPin(7), analogInputToDigitalPin(0))
-  #define DIGITAL_PIN_TO_ANALOG_PIN(P) int(IS_ANALOG(P) ? (P) - analogInputToDigitalPin(7) : -1)
+  #define DIGITAL_PIN_TO_ANALOG_PIN(P) int(analogInputToDigitalPin(0) - (P))
+  #define IS_ANALOG(P) ((P) >= analogInputToDigitalPin(7) && (P) <= analogInputToDigitalPin(0))
 #else
-  #define _ANALOG1(P) WITHIN(P, analogInputToDigitalPin(0), analogInputToDigitalPin(7))
-  #define _ANALOG2(P) WITHIN(P, analogInputToDigitalPin(8), analogInputToDigitalPin(15))
-  #define IS_ANALOG(P) (_ANALOG1(P) || _ANALOG2(P))
-  #define DIGITAL_PIN_TO_ANALOG_PIN(P) int(_ANALOG1(P) ? (P) - analogInputToDigitalPin(0) : _ANALOG2(P) ? (P) - analogInputToDigitalPin(8) + 8 : -1)
+  #define DIGITAL_PIN_TO_ANALOG_PIN(P) int((P) - analogInputToDigitalPin(0))
+  #define IS_ANALOG(P) ((P) >= analogInputToDigitalPin(0) && ((P) <= analogInputToDigitalPin(15) || (P) <= analogInputToDigitalPin(7)))
 #endif
 #define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].pin)
 #define MULTI_NAME_PAD 26 // space needed to be pretty if not first name assigned to a pin

 void PRINT_ARRAY_NAME(uint8_t x) {
-  PGM_P const name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[x].name);
-  for (uint8_t y = 0; y < MAX_NAME_LENGTH; ++y) {
+  const char * const name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[x].name);
+  LOOP_L_N(y, MAX_NAME_LENGTH) {
    char temp_char = pgm_read_byte(name_mem_pointer + y);
    if (temp_char != 0)
      SERIAL_CHAR(temp_char);
    else {
-      for (uint8_t i = 0; i < MAX_NAME_LENGTH - y; ++i) SERIAL_CHAR(' ');
+      LOOP_L_N(i, MAX_NAME_LENGTH - y) SERIAL_CHAR(' ');
      break;
    }
  }
@@ -90,6 +88,7 @@ void PRINT_ARRAY_NAME(uint8_t x) {

 #define GET_ARRAY_IS_DIGITAL(x)   pgm_read_byte(&pin_array[x].is_digital)

+
 #if defined(__AVR_ATmega1284P__)  // 1284 IDE extensions set this to the number of
  #undef NUM_DIGITAL_PINS         // digital only pins while all other CPUs have it
  #define NUM_DIGITAL_PINS 32     // set to digital only + digital/analog
@@ -109,7 +108,7 @@ void PRINT_ARRAY_NAME(uint8_t x) {
 * Print a pin's PWM status.
 * Return true if it's currently a PWM pin.
 */
-bool pwm_status(uint8_t pin) {
+static bool pwm_status(uint8_t pin) {
  char buffer[20];   // for the sprintf statements

  switch (digitalPinToTimer_DEBUG(pin)) {
@@ -232,12 +231,12 @@ const volatile uint8_t* const PWM_OCR[][3] PROGMEM = {

 #define OCR_VAL(T, L)   pgm_read_word(&PWM_OCR[T][L])

-void err_is_counter()     { SERIAL_ECHOPGM("   non-standard PWM mode"); }
-void err_is_interrupt()   { SERIAL_ECHOPGM("   compare interrupt enabled"); }
-void err_prob_interrupt() { SERIAL_ECHOPGM("   overflow interrupt enabled"); }
-void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin"); SERIAL_ECHO_SP(14); }
+static void err_is_counter()     { SERIAL_ECHOPGM("   non-standard PWM mode"); }
+static void err_is_interrupt()   { SERIAL_ECHOPGM("   compare interrupt enabled"); }
+static void err_prob_interrupt() { SERIAL_ECHOPGM("   overflow interrupt enabled"); }
+static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin"); SERIAL_ECHO_SP(14); }

-void com_print(const uint8_t N, const uint8_t Z) {
+inline void com_print(const uint8_t N, const uint8_t Z) {
  const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
  SERIAL_ECHOPGM("    COM", AS_DIGIT(N));
  SERIAL_CHAR(Z);
@@ -279,7 +278,7 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
  if (TEST(*TMSK, TOIE)) err_prob_interrupt();
 }

-void pwm_details(uint8_t pin) {
+static void pwm_details(uint8_t pin) {
  switch (digitalPinToTimer_DEBUG(pin)) {

    #if ABTEST(0)
@@ -353,41 +352,47 @@ void pwm_details(uint8_t pin) {
 } // pwm_details

 #ifndef digitalRead_mod                   // Use Teensyduino's version of digitalRead - it doesn't disable the PWMs
-  int digitalRead_mod(const pin_t pin) {  // same as digitalRead except the PWM stop section has been removed
+  int digitalRead_mod(const int8_t pin) { // same as digitalRead except the PWM stop section has been removed
    const uint8_t port = digitalPinToPort_DEBUG(pin);
    return (port != NOT_A_PIN) && (*portInputRegister(port) & digitalPinToBitMask_DEBUG(pin)) ? HIGH : LOW;
  }
 #endif

-void print_port(const pin_t pin) {   // print port number
-  #ifdef digitalPinToPort_DEBUG
-    uint8_t x;
-    SERIAL_ECHOPGM("  Port: ");
-    #if AVR_AT90USB1286_FAMILY
-      x = (pin == 46 || pin == 47) ? 'E' : digitalPinToPort_DEBUG(pin) + 64;
-    #else
-      x = digitalPinToPort_DEBUG(pin) + 64;
-    #endif
-    SERIAL_CHAR(x);
+#ifndef PRINT_PORT

-    #if AVR_AT90USB1286_FAMILY
-      if (pin == 46)
-        x = '2';
-      else if (pin == 47)
-        x = '3';
-      else {
+  void print_port(int8_t pin) {   // print port number
+    #ifdef digitalPinToPort_DEBUG
+      uint8_t x;
+      SERIAL_ECHOPGM("  Port: ");
+      #if AVR_AT90USB1286_FAMILY
+        x = (pin == 46 || pin == 47) ? 'E' : digitalPinToPort_DEBUG(pin) + 64;
+      #else
+        x = digitalPinToPort_DEBUG(pin) + 64;
+      #endif
+      SERIAL_CHAR(x);
+
+      #if AVR_AT90USB1286_FAMILY
+        if (pin == 46)
+          x = '2';
+        else if (pin == 47)
+          x = '3';
+        else {
+          uint8_t temp = digitalPinToBitMask_DEBUG(pin);
+          for (x = '0'; x < '9' && temp != 1; x++) temp >>= 1;
+        }
+      #else
        uint8_t temp = digitalPinToBitMask_DEBUG(pin);
        for (x = '0'; x < '9' && temp != 1; x++) temp >>= 1;
-      }
+      #endif
+      SERIAL_CHAR(x);
    #else
-      uint8_t temp = digitalPinToBitMask_DEBUG(pin);
-      for (x = '0'; x < '9' && temp != 1; x++) temp >>= 1;
+      SERIAL_ECHO_SP(10);
    #endif
-    SERIAL_CHAR(x);
-  #else
-    SERIAL_ECHO_SP(10);
-  #endif
-}
+  }
+
+  #define PRINT_PORT(p) print_port(p)
+
+#endif

 #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)
@@ -22,10 +22,11 @@
 #pragma once

 //
-// Some of the pin mapping functions of the Arduino IDE Teensduino extension
-// function differently from other Arduino extensions.
+//  some of the pin mapping functions of the Teensduino extension to the Arduino IDE
+//  do not function the same as the other Arduino extensions
 //

+
 #define TEENSYDUINO_IDE

 //digitalPinToTimer(pin) function works like Arduino but Timers are not defined
@@ -47,6 +48,8 @@
 #define PE 5
 #define PF 6

+#undef digitalPinToPort
+
 const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
  PD, // 0  - PD0 - INT0 - PWM
  PD, // 1  - PD1 - INT1 - PWM
@@ -98,7 +101,7 @@ const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
  PE, // 47 - PE3 (not defined in teensyduino)
 };

-#define digitalPinToPort(P) pgm_read_byte(digital_pin_to_port_PGM[P])
+#define digitalPinToPort(P) ( pgm_read_byte( digital_pin_to_port_PGM + (P) ) )

 // digitalPinToBitMask(pin) is OK

@@ -231,6 +231,7 @@ const uint8_t PROGMEM digital_pin_to_bit_mask_PGM_plus_70[] = {

 #define digitalPinToBitMask_plus_70(P) ( pgm_read_byte( digital_pin_to_bit_mask_PGM_plus_70 + (P) ) )

+
 const uint8_t PROGMEM digital_pin_to_timer_PGM_plus_70[] = {
  // TIMERS
  // ------------------------
@@ -1,979 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2023 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/>.
- *
- */
-
-#ifdef __AVR__
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(HAL_AVR_DIRTY_INIT)
-
-#include "registers.h"
-
-// Since the compiler could be creating multiple copies of function code-graphs for each header inline-inclusion,
-// we want to off-load the function definitions that define static memory into this solitary compilation unit.
-// This way the ROM is NOT bloated (who knows if the compiler is optimizing same-content constant objects into one?)
-
-ATmegaPinFunctions _ATmega_getPinFunctions(int pin) {
-  if (pin < 0) return {};
-
-  ATmegaPinInfo info = _ATmega_getPinInfo((unsigned int)pin);
-
-  #ifdef __AVR_TRM01__
-    if (info.port == eATmegaPort::PORT_A) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_B) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC0A, eATmegaPinFunc::TOC1C, eATmegaPinFunc::PCI7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1B, eATmegaPinFunc::PCI6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::PCI3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::PCI2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::PCI1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::PCI0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_C) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD15 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD14 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD13 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD12 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD11 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD10 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD9 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD8 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_D) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER0_CLKI };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_CLKI };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART1_CLK };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT3, eATmegaPinFunc::USART1_TXD };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT2, eATmegaPinFunc::USART1_RXD };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::TWI_SDA };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::TWI_CLK };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_E) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT7, eATmegaPinFunc::TIMER3_ICP, eATmegaPinFunc::CLKO };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT6, eATmegaPinFunc::TIMER3_CLKI };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT5, eATmegaPinFunc::TOC3C };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT4, eATmegaPinFunc::TOC3B };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN1, eATmegaPinFunc::TOC3A };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN0, eATmegaPinFunc::USART0_CLK };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PDO, eATmegaPinFunc::USART0_TXD };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PDI, eATmegaPinFunc::USART0_RXD, eATmegaPinFunc::PCI8 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_F) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_G) {
-      if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC0B };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3 ) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_ALE };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_RD };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_WR };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_H) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER4_CLKI };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2B };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC4C };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC4B };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC4A };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART2_CLK };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART2_TXD };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART2_RXD };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_J) {
-      if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI15 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI14 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI13 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI12 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART3_CLK, eATmegaPinFunc::PCI11 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART3_TXD, eATmegaPinFunc::PCI10 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART3_RXD, eATmegaPinFunc::PCI9 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_K) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC15, eATmegaPinFunc::PCI23 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC14, eATmegaPinFunc::PCI22 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC13, eATmegaPinFunc::PCI21 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC12, eATmegaPinFunc::PCI20 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC11, eATmegaPinFunc::PCI19 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC10, eATmegaPinFunc::PCI18 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC9, eATmegaPinFunc::PCI17 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC8, eATmegaPinFunc::PCI16 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_L) {
-      if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC5C };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC5B };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC5A };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER5_CLKI };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER5_ICP };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER4_ICP };
-        return { funcs, countof(funcs) };
-      }
-    }
-  #elif defined(__AVR_TRM02__)
-    if (info.port == eATmegaPort::PORT_A) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI7, eATmegaPinFunc::ADC7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI6, eATmegaPinFunc::ADC6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI5, eATmegaPinFunc::ADC5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI4, eATmegaPinFunc::ADC4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI3, eATmegaPinFunc::ADC3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI2, eATmegaPinFunc::ADC2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI1, eATmegaPinFunc::ADC1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI0, eATmegaPinFunc::ADC0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_B) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::TOC3B, eATmegaPinFunc::PCI15 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::TOC3A, eATmegaPinFunc::PCI14 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::TIMER3_ICP, eATmegaPinFunc::PCI13 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::TOC0B, eATmegaPinFunc::PCI12 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN1, eATmegaPinFunc::TOC0A, eATmegaPinFunc::PCI11 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN0, eATmegaPinFunc::EINT2, eATmegaPinFunc::PCI10 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ECI, eATmegaPinFunc::CLKO, eATmegaPinFunc::PCI9 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER0_ECI, eATmegaPinFunc::USART0_CLK, eATmegaPinFunc::PCI8 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_C) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC2, eATmegaPinFunc::PCI23 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC1, eATmegaPinFunc::PCI22 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI21 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI20 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI19 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI18 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI17, eATmegaPinFunc::TWI_SDA };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TWI_CLK, eATmegaPinFunc::PCI16 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_D) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI31 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP, eATmegaPinFunc::TOC2B, eATmegaPinFunc::PCI30 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI29 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1B, eATmegaPinFunc::USART1_CLK, eATmegaPinFunc::PCI28 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::USART1_TXD, eATmegaPinFunc::PCI27 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::USART1_RXD, eATmegaPinFunc::PCI26 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART0_TXD, eATmegaPinFunc::PCI25 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART0_TXD, eATmegaPinFunc::PCI24, eATmegaPinFunc::TIMER3_ECI };
-        return { funcs, countof(funcs) };
-      }
-    }
-  #elif defined(__AVR_TRM03__)
-    if (info.port == eATmegaPort::PORT_B) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::XTAL2, eATmegaPinFunc::TOSC2, eATmegaPinFunc::PCI7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::XTAL1, eATmegaPinFunc::TOSC1, eATmegaPinFunc::PCI6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::PCI5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::PCI4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::TOC1B, eATmegaPinFunc::PCI2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP, eATmegaPinFunc::CLKO, eATmegaPinFunc::PCI0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_C) {
-      if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI14 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC5, eATmegaPinFunc::TWI_CLK, eATmegaPinFunc::PCI13 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC4, eATmegaPinFunc::TWI_SDA, eATmegaPinFunc::PCI12 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC3, eATmegaPinFunc::PCI11 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC2, eATmegaPinFunc::PCI10 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC1, eATmegaPinFunc::PCI9 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC0, eATmegaPinFunc::PCI8 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_D) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN1, eATmegaPinFunc::PCI23 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN0, eATmegaPinFunc::TOC0A, eATmegaPinFunc::PCI22 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ECI, eATmegaPinFunc::TOC0B, eATmegaPinFunc::PCI21 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART_CLK, eATmegaPinFunc::TIMER0_ECI, eATmegaPinFunc::PCI20 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::TOC2B, eATmegaPinFunc::PCI19 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::PCI18 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART_TXD, eATmegaPinFunc::PCI17 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART_RXD, eATmegaPinFunc::PCI16 };
-        return { funcs, countof(funcs) };
-      }
-    }
-  #elif defined(__AVR_TRM04__)
-    if (info.port == eATmegaPort::PORT_A) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_B) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC0A, eATmegaPinFunc::TOC1C, eATmegaPinFunc::PCI7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1B, eATmegaPinFunc::PCI6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PDO, eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::PCI3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PDI, eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::PCI2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::PCI1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::PCI0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_C) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD15, eATmegaPinFunc::TIMER3_ICP, eATmegaPinFunc::CLKO };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD14, eATmegaPinFunc::TOC3A };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD13, eATmegaPinFunc::TOC3B };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD12, eATmegaPinFunc::TOC3C };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD11, eATmegaPinFunc::TIMER3_CLKI };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD10 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD9 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD8 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_D) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER0_CLKI };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_CLKI };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART1_CLK };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT3, eATmegaPinFunc::USART1_TXD };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT2, eATmegaPinFunc::USART1_RXD };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::TWI_SDA, eATmegaPinFunc::TOC2B };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::TWI_CLK, eATmegaPinFunc::TOC0B };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_E) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT7, eATmegaPinFunc::AIN1, eATmegaPinFunc::UVCON };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT6, eATmegaPinFunc::AIN0 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT5, eATmegaPinFunc::TOSC2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT4, eATmegaPinFunc::TOSC2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::UID };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_ALE };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_RD };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_WR };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_F) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-  #elif defined(__AVR_TRM05__)
-    if (info.port == eATmegaPort::PORT_A) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC7, eATmegaPinFunc::PCI7 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC6, eATmegaPinFunc::PCI6 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC5, eATmegaPinFunc::PCI5 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC4, eATmegaPinFunc::PCI4 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC3, eATmegaPinFunc::PCI3 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC2, eATmegaPinFunc::PCI2 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC1, eATmegaPinFunc::PCI1 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC0, eATmegaPinFunc::PCI0 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_B) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::PCI15 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::PCI14 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::PCI13 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::TOC0B, eATmegaPinFunc::PCI12 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN1, eATmegaPinFunc::TOC0A, eATmegaPinFunc::PCI11 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN0, eATmegaPinFunc::EINT2, eATmegaPinFunc::PCI10 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ECI, eATmegaPinFunc::CLKO, eATmegaPinFunc::PCI9 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER0_ECI, eATmegaPinFunc::USART0_CLK, eATmegaPinFunc::PCI8 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_C) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC2, eATmegaPinFunc::PCI23 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC1, eATmegaPinFunc::PCI22 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI21 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI20 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI19 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI18 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TWI_SDA, eATmegaPinFunc::PCI17 };
-        return { funcs, countof(funcs) };
-      }
-      else if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TWI_CLK, eATmegaPinFunc::PCI16 };
-        return { funcs, countof(funcs) };
-      }
-    }
-    else if (info.port == eATmegaPort::PORT_D) {
-      if (info.pinidx == 7) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI31 };
-        return { funcs, countof(funcs) };
-      }
-      if (info.pinidx == 6) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP, eATmegaPinFunc::TOC2B, eATmegaPinFunc::PCI30 };
-        return { funcs, countof(funcs) };
-      }
-      if (info.pinidx == 5) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI29 };
-        return { funcs, countof(funcs) };
-      }
-      if (info.pinidx == 4) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1B, eATmegaPinFunc::USART1_CLK, eATmegaPinFunc::PCI28 };
-        return { funcs, countof(funcs) };
-      }
-      if (info.pinidx == 3) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::USART1_TXD, eATmegaPinFunc::PCI27 };
-        return { funcs, countof(funcs) };
-      }
-      if (info.pinidx == 2) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::USART1_RXD, eATmegaPinFunc::PCI26 };
-        return { funcs, countof(funcs) };
-      }
-      if (info.pinidx == 1) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART0_TXD, eATmegaPinFunc::PCI25 };
-        return { funcs, countof(funcs) };
-      }
-      if (info.pinidx == 0) {
-        static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART0_RXD, eATmegaPinFunc::PCI24 };
-        return { funcs, countof(funcs) };
-      }
-    }
-  #endif
-
-  return ATmegaPinFunctions();  // default and empty.
-}
-
-#endif // HAL_AVR_DIRTY_INIT
-#endif // __AVR__
@@ -44,14 +44,14 @@ typedef uint16_t hal_timer_t;
  #define MF_TIMER_TEMP         0
 #endif

-#define TEMP_TIMER_FREQUENCY    (((F_CPU) + 0x2000) / 0x4000)
+#define TEMP_TIMER_FREQUENCY    ((F_CPU) / 64.0 / 256.0)

 #define STEPPER_TIMER_RATE      HAL_TIMER_RATE
 #define STEPPER_TIMER_PRESCALE  8
-#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000)
+#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // Cannot be of type double

-#define PULSE_TIMER_RATE         STEPPER_TIMER_RATE
-#define PULSE_TIMER_PRESCALE     STEPPER_TIMER_PRESCALE
+#define PULSE_TIMER_RATE       STEPPER_TIMER_RATE   // frequency of pulse timer
+#define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US

 #define ENABLE_STEPPER_DRIVER_INTERRUPT()  SBI(TIMSK1, OCIE1A)
@@ -88,7 +88,7 @@ void u8g_spiSend_sw_AVR_mode_0(uint8_t val) {
  volatile uint8_t *outData = u8g_outData,
                   *outClock = u8g_outClock;
  U8G_ATOMIC_START();
-  for (uint8_t i = 0; i < 8; ++i) {
+  LOOP_L_N(i, 8) {
    if (val & 0x80)
      *outData |= bitData;
    else
@@ -108,7 +108,7 @@ void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
  volatile uint8_t *outData = u8g_outData,
                   *outClock = u8g_outClock;
  U8G_ATOMIC_START();
-  for (uint8_t i = 0; i < 8; ++i) {
+  LOOP_L_N(i, 8) {
    *outClock &= bitNotClock;
    if (val & 0x80)
      *outData |= bitData;
@@ -45,7 +45,7 @@ uint16_t MarlinHAL::adc_result;
 #endif

 void MarlinHAL::init() {
-  #if HAS_MEDIA
+  #if ENABLED(SDSUPPORT)
    OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up
  #endif
  usb_task_init();          // Initialize the USB stack
@@ -123,7 +123,7 @@ typedef Servo hal_servo_t;
 //
 // ADC
 //
-#define HAL_ADC_VREF_MV   3300
+#define HAL_ADC_VREF         3.3
 #define HAL_ADC_RESOLUTION  10

 #ifndef analogInputToDigitalPin
@@ -210,7 +210,7 @@ public:
  static void adc_init() {}

  // Called by Temperature::init for each sensor at startup
-  static void adc_enable(const uint8_t /*ch*/) {}
+  static void adc_enable(const uint8_t ch) {}

  // Begin ADC sampling on the given channel. Called from Temperature::isr!
  static void adc_start(const uint8_t ch) { adc_result = analogRead(ch); }
@@ -42,7 +42,7 @@
 // Public functions
 // ------------------------

-#if ANY(DUE_SOFTWARE_SPI, FORCE_SOFT_SPI)
+#if EITHER(DUE_SOFTWARE_SPI, FORCE_SOFT_SPI)

  // ------------------------
  // Software SPI
@@ -247,12 +247,12 @@
      b <<= 1; // little setup time

      WRITE(SD_SCK_PIN, HIGH);
-      DELAY_NS_VAR(spiDelayNS);
+      DELAY_NS(spiDelayNS);

      b |= (READ(SD_MISO_PIN) != 0);

      WRITE(SD_SCK_PIN, LOW);
-      DELAY_NS_VAR(spiDelayNS);
+      DELAY_NS(spiDelayNS);
    } while (--bits);
    return b;
  }
@@ -41,7 +41,7 @@
   practice, we need alignment to 256 bytes to make this work in all
   cases */
 __attribute__ ((aligned(256)))
-static DeviceVectors ram_tab[61] = { nullptr };
+static DeviceVectors ram_tab = { nullptr };

 /**
 * This function checks if the exception/interrupt table is already in SRAM or not.
@@ -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;
@@ -73,18 +73,18 @@ void install_min_serial() {
 }

 #if DISABLED(DYNAMIC_VECTORTABLE)
-  extern "C" {
-    __attribute__((naked)) void JumpHandler_ASM() {
-      __asm__ __volatile__ (
-        "b CommonHandler_ASM\n"
-      );
-    }
-    void __attribute__((naked, alias("JumpHandler_ASM"))) HardFault_Handler();
-    void __attribute__((naked, alias("JumpHandler_ASM"))) BusFault_Handler();
-    void __attribute__((naked, alias("JumpHandler_ASM"))) UsageFault_Handler();
-    void __attribute__((naked, alias("JumpHandler_ASM"))) MemManage_Handler();
-    void __attribute__((naked, alias("JumpHandler_ASM"))) NMI_Handler();
+extern "C" {
+  __attribute__((naked)) void JumpHandler_ASM() {
+    __asm__ __volatile__ (
+      "b CommonHandler_ASM\n"
+    );
  }
+  void __attribute__((naked, alias("JumpHandler_ASM"))) HardFault_Handler();
+  void __attribute__((naked, alias("JumpHandler_ASM"))) BusFault_Handler();
+  void __attribute__((naked, alias("JumpHandler_ASM"))) UsageFault_Handler();
+  void __attribute__((naked, alias("JumpHandler_ASM"))) MemManage_Handler();
+  void __attribute__((naked, alias("JumpHandler_ASM"))) NMI_Handler();
+}
 #endif

 #endif // POSTMORTEM_DEBUGGING
@@ -47,12 +47,12 @@
 #include "../shared/servo.h"
 #include "../shared/servo_private.h"

-static Flags<_Nbr_16timers> DisablePending; // ISR should disable the timer at the next timer reset
+static volatile int8_t Channel[_Nbr_16timers];              // counter for the servo being pulsed for each timer (or -1 if refresh interval)

 // ------------------------
 /// Interrupt handler for the TC0 channel 1.
 // ------------------------
-void Servo_Handler(const timer16_Sequence_t, Tc*, const uint8_t);
+void Servo_Handler(timer16_Sequence_t timer, Tc *pTc, uint8_t channel);

 #ifdef _useTimer1
  void HANDLER_FOR_TIMER1() { Servo_Handler(_timer1, TC_FOR_TIMER1, CHANNEL_FOR_TIMER1); }
@@ -70,92 +70,88 @@ void Servo_Handler(const timer16_Sequence_t, Tc*, const uint8_t);
  void HANDLER_FOR_TIMER5() { Servo_Handler(_timer5, TC_FOR_TIMER5, CHANNEL_FOR_TIMER5); }
 #endif

-void Servo_Handler(const timer16_Sequence_t timer, Tc *tc, const uint8_t channel) {
-  static int8_t Channel[_Nbr_16timers];                               // Servo counters to pulse (or -1 for refresh interval)
-  int8_t cho = Channel[timer];                                        // Handle the prior Channel[timer] first
-  if (cho < 0) {                                                      // Channel -1 indicates the refresh interval completed...
-    tc->TC_CHANNEL[channel].TC_CCR |= TC_CCR_SWTRG;                   // ...so reset the timer
-    if (DisablePending[timer]) {
-      // Disabling only after the full servo period expires prevents
-      // pulses being too close together if immediately re-enabled.
-      DisablePending.clear(timer);
-      TC_Stop(tc, channel);
-      tc->TC_CHANNEL[channel].TC_SR;                                  // clear interrupt
-      return;
-    }
-  }
-  else if (SERVO_INDEX(timer, cho) < ServoCount)                      // prior channel handled?
-    extDigitalWrite(SERVO(timer, cho).Pin.nbr, LOW);                  // pulse the prior channel LOW
+void Servo_Handler(timer16_Sequence_t timer, Tc *tc, uint8_t channel) {
+  // clear interrupt
+  tc->TC_CHANNEL[channel].TC_SR;
+  if (Channel[timer] < 0)
+    tc->TC_CHANNEL[channel].TC_CCR |= TC_CCR_SWTRG; // channel set to -1 indicated that refresh interval completed so reset the timer
+  else if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && SERVO(timer, Channel[timer]).Pin.isActive)
+    extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, LOW); // pulse this channel low if activated

-  Channel[timer] = ++cho;                                             // go to the next channel (or 0)
-  if (cho < SERVOS_PER_TIMER && SERVO_INDEX(timer, cho) < ServoCount) {
-    tc->TC_CHANNEL[channel].TC_RA = tc->TC_CHANNEL[channel].TC_CV + SERVO(timer, cho).ticks;
-    if (SERVO(timer, cho).Pin.isActive)                               // activated?
-      extDigitalWrite(SERVO(timer, cho).Pin.nbr, HIGH);               // yes: pulse HIGH
+  Channel[timer]++;    // increment to the next channel
+  if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
+    tc->TC_CHANNEL[channel].TC_RA = tc->TC_CHANNEL[channel].TC_CV + SERVO(timer,Channel[timer]).ticks;
+    if (SERVO(timer,Channel[timer]).Pin.isActive)    // check if activated
+      extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, HIGH); // its an active channel so pulse it high
  }
  else {
    // finished all channels so wait for the refresh period to expire before starting over
-    const unsigned int cval = tc->TC_CHANNEL[channel].TC_CV + 128 / (SERVO_TIMER_PRESCALER), // allow 128 cycles to ensure the next CV not missed
-                       ival = (unsigned int)usToTicks(REFRESH_INTERVAL); // at least REFRESH_INTERVAL has elapsed
-    tc->TC_CHANNEL[channel].TC_RA = max(cval, ival);
-
-    Channel[timer] = -1;                                              // reset the timer CCR on the next call
+    tc->TC_CHANNEL[channel].TC_RA =
+      tc->TC_CHANNEL[channel].TC_CV < usToTicks(REFRESH_INTERVAL) - 4
+        ? (unsigned int)usToTicks(REFRESH_INTERVAL) // allow a few ticks to ensure the next OCR1A not missed
+        : tc->TC_CHANNEL[channel].TC_CV + 4;        // at least REFRESH_INTERVAL has elapsed
+    Channel[timer] = -1; // this will get incremented at the end of the refresh period to start again at the first channel
  }
-
-  tc->TC_CHANNEL[channel].TC_SR;                                      // clear interrupt
 }

 static void _initISR(Tc *tc, uint32_t channel, uint32_t id, IRQn_Type irqn) {
  pmc_enable_periph_clk(id);
  TC_Configure(tc, channel,
-      TC_CMR_WAVE                   // Waveform mode
-    | TC_CMR_WAVSEL_UP_RC           // Counter running up and reset when equal to RC
-    | (SERVO_TIMER_PRESCALER ==   2 ? TC_CMR_TCCLKS_TIMER_CLOCK1 : 0) // MCK/2
-    | (SERVO_TIMER_PRESCALER ==   8 ? TC_CMR_TCCLKS_TIMER_CLOCK2 : 0) // MCK/8
-    | (SERVO_TIMER_PRESCALER ==  32 ? TC_CMR_TCCLKS_TIMER_CLOCK3 : 0) // MCK/32
-    | (SERVO_TIMER_PRESCALER == 128 ? TC_CMR_TCCLKS_TIMER_CLOCK4 : 0) // MCK/128
-  );
+    TC_CMR_TCCLKS_TIMER_CLOCK3 | // MCK/32
+    TC_CMR_WAVE |                // Waveform mode
+    TC_CMR_WAVSEL_UP_RC );       // Counter running up and reset when equals to RC

-  // Wait 1ms before the first ISR
-  TC_SetRA(tc, channel, (F_CPU) / (SERVO_TIMER_PRESCALER) / 1000UL); // 1ms
+  /* 84MHz, MCK/32, for 1.5ms: 3937 */
+  TC_SetRA(tc, channel, 2625); // 1ms

-  // Configure and enable interrupt
+  /* Configure and enable interrupt */
  NVIC_EnableIRQ(irqn);
-  tc->TC_CHANNEL[channel].TC_IER = TC_IER_CPAS; // TC_IER_CPAS: RA Compare
+  // TC_IER_CPAS: RA Compare
+  tc->TC_CHANNEL[channel].TC_IER = TC_IER_CPAS;

  // Enables the timer clock and performs a software reset to start the counting
  TC_Start(tc, channel);
 }

-void initISR(const timer16_Sequence_t timer_index) {
-  CRITICAL_SECTION_START();
-  const bool disable_soon = DisablePending[timer_index];
-  DisablePending.clear(timer_index);
-  CRITICAL_SECTION_END();
-
-  if (!disable_soon) switch (timer_index) {
-    default: break;
-    #ifdef _useTimer1
-      case _timer1: return _initISR(TC_FOR_TIMER1, CHANNEL_FOR_TIMER1, ID_TC_FOR_TIMER1, IRQn_FOR_TIMER1);
-    #endif
-    #ifdef _useTimer2
-      case _timer2: return _initISR(TC_FOR_TIMER2, CHANNEL_FOR_TIMER2, ID_TC_FOR_TIMER2, IRQn_FOR_TIMER2);
-    #endif
-    #ifdef _useTimer3
-      case _timer3: return _initISR(TC_FOR_TIMER3, CHANNEL_FOR_TIMER3, ID_TC_FOR_TIMER3, IRQn_FOR_TIMER3);
-    #endif
-    #ifdef _useTimer4
-      case _timer4: return _initISR(TC_FOR_TIMER4, CHANNEL_FOR_TIMER4, ID_TC_FOR_TIMER4, IRQn_FOR_TIMER4);
-    #endif
-    #ifdef _useTimer5
-      case _timer5: return _initISR(TC_FOR_TIMER5, CHANNEL_FOR_TIMER5, ID_TC_FOR_TIMER5, IRQn_FOR_TIMER5);
-    #endif
-  }
+void initISR(timer16_Sequence_t timer) {
+  #ifdef _useTimer1
+    if (timer == _timer1)
+      _initISR(TC_FOR_TIMER1, CHANNEL_FOR_TIMER1, ID_TC_FOR_TIMER1, IRQn_FOR_TIMER1);
+  #endif
+  #ifdef _useTimer2
+    if (timer == _timer2)
+      _initISR(TC_FOR_TIMER2, CHANNEL_FOR_TIMER2, ID_TC_FOR_TIMER2, IRQn_FOR_TIMER2);
+  #endif
+  #ifdef _useTimer3
+    if (timer == _timer3)
+      _initISR(TC_FOR_TIMER3, CHANNEL_FOR_TIMER3, ID_TC_FOR_TIMER3, IRQn_FOR_TIMER3);
+  #endif
+  #ifdef _useTimer4
+    if (timer == _timer4)
+      _initISR(TC_FOR_TIMER4, CHANNEL_FOR_TIMER4, ID_TC_FOR_TIMER4, IRQn_FOR_TIMER4);
+  #endif
+  #ifdef _useTimer5
+    if (timer == _timer5)
+      _initISR(TC_FOR_TIMER5, CHANNEL_FOR_TIMER5, ID_TC_FOR_TIMER5, IRQn_FOR_TIMER5);
+  #endif
 }

-void finISR(const timer16_Sequence_t timer_index) {
-  // Timer is disabled from the ISR, to ensure proper final pulse length.
-  DisablePending.set(timer_index);
+void finISR(timer16_Sequence_t) {
+  #ifdef _useTimer1
+    TC_Stop(TC_FOR_TIMER1, CHANNEL_FOR_TIMER1);
+  #endif
+  #ifdef _useTimer2
+    TC_Stop(TC_FOR_TIMER2, CHANNEL_FOR_TIMER2);
+  #endif
+  #ifdef _useTimer3
+    TC_Stop(TC_FOR_TIMER3, CHANNEL_FOR_TIMER3);
+  #endif
+  #ifdef _useTimer4
+    TC_Stop(TC_FOR_TIMER4, CHANNEL_FOR_TIMER4);
+  #endif
+  #ifdef _useTimer5
+    TC_Stop(TC_FOR_TIMER5, CHANNEL_FOR_TIMER5);
+  #endif
 }

 #endif // HAS_SERVOS
@@ -37,7 +37,7 @@
 #define _useTimer5

 #define TRIM_DURATION             2   // compensation ticks to trim adjust for digitalWrite delays
-#define SERVO_TIMER_PRESCALER     2   // timer prescaler
+#define SERVO_TIMER_PRESCALER     32  // timer prescaler

 /*
  TC0, chan 0 => TC0_Handler
@@ -81,7 +81,7 @@ Pio *SCK_pPio, *MOSI_pPio;
 uint32_t SCK_dwMask, MOSI_dwMask;

 void u8g_spiSend_sw_DUE_mode_0(uint8_t val) { // 3MHz
-  for (uint8_t i = 0; i < 8; ++i) {
+  LOOP_L_N(i, 8) {
    if (val & 0x80)
      MOSI_pPio->PIO_SODR = MOSI_dwMask;
    else
@@ -95,7 +95,7 @@ void u8g_spiSend_sw_DUE_mode_0(uint8_t val) { // 3MHz
 }

 void u8g_spiSend_sw_DUE_mode_3(uint8_t val) { // 3.5MHz
-  for (uint8_t i = 0; i < 8; ++i) {
+  LOOP_L_N(i, 8) {
    SCK_pPio->PIO_CODR = SCK_dwMask;
    DELAY_NS(50);
    if (val & 0x80)
@@ -47,33 +47,33 @@ void endstop_ISR() { endstops.update(); }

 void setup_endstop_interrupts() {
  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
-  TERN_(USE_X_MAX,       _ATTACH(X_MAX_PIN));
-  TERN_(USE_X_MIN,       _ATTACH(X_MIN_PIN));
-  TERN_(USE_Y_MAX,       _ATTACH(Y_MAX_PIN));
-  TERN_(USE_Y_MIN,       _ATTACH(Y_MIN_PIN));
-  TERN_(USE_Z_MAX,       _ATTACH(Z_MAX_PIN));
-  TERN_(USE_Z_MIN,       _ATTACH(Z_MIN_PIN));
-  TERN_(USE_X2_MAX,      _ATTACH(X2_MAX_PIN));
-  TERN_(USE_X2_MIN,      _ATTACH(X2_MIN_PIN));
-  TERN_(USE_Y2_MAX,      _ATTACH(Y2_MAX_PIN));
-  TERN_(USE_Y2_MIN,      _ATTACH(Y2_MIN_PIN));
-  TERN_(USE_Z2_MAX,      _ATTACH(Z2_MAX_PIN));
-  TERN_(USE_Z2_MIN,      _ATTACH(Z2_MIN_PIN));
-  TERN_(USE_Z3_MAX,      _ATTACH(Z3_MAX_PIN));
-  TERN_(USE_Z3_MIN,      _ATTACH(Z3_MIN_PIN));
-  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
-  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
-  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
-  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
-  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
-  TERN_(USE_J_MIN,       _ATTACH(J_MIN_PIN));
-  TERN_(USE_K_MAX,       _ATTACH(K_MAX_PIN));
-  TERN_(USE_K_MIN,       _ATTACH(K_MIN_PIN));
-  TERN_(USE_U_MAX,       _ATTACH(U_MAX_PIN));
-  TERN_(USE_U_MIN,       _ATTACH(U_MIN_PIN));
-  TERN_(USE_V_MAX,       _ATTACH(V_MAX_PIN));
-  TERN_(USE_V_MIN,       _ATTACH(V_MIN_PIN));
-  TERN_(USE_W_MAX,       _ATTACH(W_MAX_PIN));
-  TERN_(USE_W_MIN,       _ATTACH(W_MIN_PIN));
+  TERN_(HAS_X_MAX, _ATTACH(X_MAX_PIN));
+  TERN_(HAS_X_MIN, _ATTACH(X_MIN_PIN));
+  TERN_(HAS_Y_MAX, _ATTACH(Y_MAX_PIN));
+  TERN_(HAS_Y_MIN, _ATTACH(Y_MIN_PIN));
+  TERN_(HAS_Z_MAX, _ATTACH(Z_MAX_PIN));
+  TERN_(HAS_Z_MIN, _ATTACH(Z_MIN_PIN));
+  TERN_(HAS_X2_MAX, _ATTACH(X2_MAX_PIN));
+  TERN_(HAS_X2_MIN, _ATTACH(X2_MIN_PIN));
+  TERN_(HAS_Y2_MAX, _ATTACH(Y2_MAX_PIN));
+  TERN_(HAS_Y2_MIN, _ATTACH(Y2_MIN_PIN));
+  TERN_(HAS_Z2_MAX, _ATTACH(Z2_MAX_PIN));
+  TERN_(HAS_Z2_MIN, _ATTACH(Z2_MIN_PIN));
+  TERN_(HAS_Z3_MAX, _ATTACH(Z3_MAX_PIN));
+  TERN_(HAS_Z3_MIN, _ATTACH(Z3_MIN_PIN));
+  TERN_(HAS_Z4_MAX, _ATTACH(Z4_MAX_PIN));
+  TERN_(HAS_Z4_MIN, _ATTACH(Z4_MIN_PIN));
+  TERN_(HAS_Z_MIN_PROBE_PIN, _ATTACH(Z_MIN_PROBE_PIN));
+  TERN_(HAS_I_MAX, _ATTACH(I_MAX_PIN));
+  TERN_(HAS_I_MIN, _ATTACH(I_MIN_PIN));
+  TERN_(HAS_J_MAX, _ATTACH(J_MAX_PIN));
+  TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
+  TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
+  TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
+  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
+  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
+  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
+  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
+  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
+  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }
@@ -189,12 +189,12 @@
 */

 // UART
-#define RXD        0
-#define TXD        1
+#define RXD        DIO0
+#define TXD        DIO1

 // TWI (I2C)
-#define SCL        21
-#define SDA        20
+#define SCL        DIO21
+#define SDA        DIO20

 /**
 * pins
@@ -63,7 +63,7 @@ extern PWM_map ISR_table[NUM_PWMS];
 extern uint32_t motor_current_setting[3];

 #define IR_BIT(p) (WITHIN(p, 0, 3) ? (p) : (p) + 4)
-#define COPY_ACTIVE_TABLE() do{ for (uint8_t i = 0; i < 6; ++i) work_table[i] = active_table[i]; }while(0)
+#define COPY_ACTIVE_TABLE() do{ LOOP_L_N(i, 6) work_table[i] = active_table[i]; }while(0)

 #define PWM_MR0 19999         // base repetition rate minus one count - 20mS
 #define PWM_PR 24             // prescaler value - prescaler divide by 24 + 1  -  1 MHz output
@@ -20,3 +20,7 @@
 *
 */
 #pragma once
+
+#if HAS_SPI_TFT || HAS_FSMC_TFT
+  #error "Sorry! TFT displays are not available for HAL/DUE."
+#endif
@@ -23,6 +23,6 @@

 #if USE_FALLBACK_EEPROM
  #define FLASH_EEPROM_EMULATION
-#elif ANY(I2C_EEPROM, SPI_EEPROM)
+#elif EITHER(I2C_EEPROM, SPI_EEPROM)
  #define USE_SHARED_EEPROM 1
 #endif
@@ -25,10 +25,6 @@
 * Test Arduino Due specific configuration values for errors at compile-time.
 */

-#if HAS_SPI_TFT || HAS_FSMC_TFT
-  #error "Sorry! TFT displays are not available for HAL/DUE."
-#endif
-
 /**
 * Check for common serial pin conflicts
 */
@@ -40,15 +36,15 @@
  || X_DIR_PIN  == N || Y_DIR_PIN  == N || Z_DIR_PIN  == N \
  || X_ENA_PIN  == N || Y_ENA_PIN  == N || Z_ENA_PIN  == N \
 )
-#if SERIAL_IN_USE(0) // D0-D1. No known conflicts.
+#if CONF_SERIAL_IS(0) // D0-D1. No known conflicts.
 #endif
-#if SERIAL_IN_USE(1) && (CHECK_SERIAL_PIN(18) || CHECK_SERIAL_PIN(19))
+#if CONF_SERIAL_IS(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
-#if SERIAL_IN_USE(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
+#if CONF_SERIAL_IS(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
  #error "Serial Port 2 pin D16 and/or D17 conflicts with another pin on the board."
 #endif
-#if SERIAL_IN_USE(3) && (CHECK_SERIAL_PIN(14) || CHECK_SERIAL_PIN(15))
+#if CONF_SERIAL_IS(3) && (CHECK_SERIAL_PIN(14) || CHECK_SERIAL_PIN(15))
  #error "Serial Port 3 pin D14 and/or D15 conflicts with another pin on the board."
 #endif
 #undef CHECK_SERIAL_PIN
@@ -68,9 +64,9 @@
 * Usually the hardware SPI pins are only available to the LCD. This makes the DUE hard SPI used at the same time
 * as the TMC2130 soft SPI the most common setup.
 */
-#define _IS_HW_SPI(P) (defined(TMC_SPI_##P) && (TMC_SPI_##P == SD_MOSI_PIN || TMC_SPI_##P == SD_MISO_PIN || TMC_SPI_##P == SD_SCK_PIN))
+#define _IS_HW_SPI(P) (defined(TMC_SW_##P) && (TMC_SW_##P == SD_MOSI_PIN || TMC_SW_##P == SD_MISO_PIN || TMC_SW_##P == SD_SCK_PIN))

-#if HAS_MEDIA && HAS_DRIVER(TMC2130)
+#if ENABLED(SDSUPPORT) && HAS_DRIVER(TMC2130)
  #if ENABLED(TMC_USE_SW_SPI)
    #if DISABLED(DUE_SOFTWARE_SPI) && (_IS_HW_SPI(MOSI) || _IS_HW_SPI(MISO) || _IS_HW_SPI(SCK))
      #error "DUE hardware SPI is required but is incompatible with TMC2130 software SPI. Either disable TMC_USE_SW_SPI or use separate pins for the two SPIs."
@@ -81,7 +77,7 @@
 #endif

 #if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_FREQUENCY
-  #error "Features requiring Hardware PWM (FAST_PWM_FAN, SPINDLE_LASER_FREQUENCY) are not yet supported for HAL/DUE."
+  #error "Features requiring Hardware PWM (FAST_PWM_FAN, SPINDLE_LASER_FREQUENCY) are not yet supported on DUE."
 #endif

 #if HAS_TMC_SW_SERIAL
@@ -64,12 +64,13 @@
 #define NUMBER_PINS_TOTAL PINS_COUNT

 #define digitalRead_mod(p) extDigitalRead(p)  // AVR digitalRead disabled PWM before it read the pin
+#define PRINT_PORT(p)
 #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("%02d"), 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 VALID_PIN(pin) (pin >= 0 && pin < (int8_t)NUMBER_PINS_TOTAL ? 1 : 0)
 #define DIGITAL_PIN_TO_ANALOG_PIN(p) int(p - analogInputToDigitalPin(0))
 #define IS_ANALOG(P) WITHIN(P, char(analogInputToDigitalPin(0)), char(analogInputToDigitalPin(NUM_ANALOG_INPUTS - 1)))
 #define pwm_status(pin) (((g_pinStatus[pin] & 0xF) == PIN_STATUS_PWM) && \
@@ -92,8 +93,6 @@ void pwm_details(int32_t pin) {
  }
 }

-void print_port(const pin_t) {}
-
 /**
 * DUE Board pin   |  PORT  | Label
 * ----------------+--------+-------
@@ -89,17 +89,10 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
  NVIC_SetPriority(irq, timer_config[timer_num].priority);

  // wave mode, reset counter on match with RC,
-  TC_Configure(tc, channel,
-      TC_CMR_WAVE
-    | TC_CMR_WAVSEL_UP_RC
-    | (HAL_TIMER_PRESCALER ==   2 ? TC_CMR_TCCLKS_TIMER_CLOCK1 : 0)
-    | (HAL_TIMER_PRESCALER ==   8 ? TC_CMR_TCCLKS_TIMER_CLOCK2 : 0)
-    | (HAL_TIMER_PRESCALER ==  32 ? TC_CMR_TCCLKS_TIMER_CLOCK3 : 0)
-    | (HAL_TIMER_PRESCALER == 128 ? TC_CMR_TCCLKS_TIMER_CLOCK4 : 0)
-  );
+  TC_Configure(tc, channel, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK1);

  // Set compare value
-  TC_SetRC(tc, channel, VARIANT_MCK / (HAL_TIMER_PRESCALER) / frequency);
+  TC_SetRC(tc, channel, VARIANT_MCK / 2 / frequency);

  // And start timer
  TC_Start(tc, channel);
@@ -35,8 +35,7 @@
 typedef uint32_t hal_timer_t;
 #define HAL_TIMER_TYPE_MAX 0xFFFFFFFF

-#define HAL_TIMER_PRESCALER    2
-#define HAL_TIMER_RATE         ((F_CPU) / (HAL_TIMER_PRESCALER))  // frequency of timers peripherals
+#define HAL_TIMER_RATE         ((F_CPU) / 2)    // frequency of timers peripherals

 #ifndef MF_TIMER_STEP
  #define MF_TIMER_STEP         2  // Timer Index for Stepper
@@ -6,14 +6,14 @@
 #
 import pioutil
 if pioutil.is_pio_build():
-    import platform
-    current_OS = platform.system()
+	import platform
+	current_OS = platform.system()

-    if current_OS == 'Windows':
+	if current_OS == 'Windows':

-        Import("env")
+		Import("env")

-        # Use bossac.exe on Windows
-        env.Replace(
-            UPLOADCMD="bossac --info --unlock --write --verify --reset --erase -U false --boot $SOURCE"
-        )
+		# Use bossac.exe on Windows
+		env.Replace(
+			UPLOADCMD="bossac --info --unlock --write --verify --reset --erase -U false --boot $SOURCE"
+		)
@@ -1059,7 +1059,7 @@ static inline void convert_64_bit_to_byte_array(uint64_t value, uint8_t *data)
    while (val_index < 8)
    {
        data[val_index++] = value & 0xFF;
-        value >>= 8;
+        value = value >> 8;
    }
 }

@@ -101,7 +101,7 @@
 #define  USB_DEVICE_SPECIFIC_REQUEST()  usb_task_other_requests()
 //@}

-#if HAS_MEDIA
+#if ENABLED(SDSUPPORT)
  /**
   * USB Device low level configuration
   * When only one interface is used, these configurations are defined by the class module.
@@ -185,7 +185,7 @@
 //! Enable id string of interface to add an extra USB string
 #define  UDI_CDC_IAD_STRING_ID            4

-#if HAS_MEDIA
+#if ENABLED(SDSUPPORT)
  /**
   * USB CDC low level configuration
   * In standalone these configurations are defined by the CDC module.
@@ -74,17 +74,17 @@ extern "C" {
 //@{

 enum genclk_source {
-  GENCLK_PCK_SRC_SLCK_RC       = 0, //!< Internal 32kHz RC oscillator as PCK source clock
-  GENCLK_PCK_SRC_SLCK_XTAL     = 1, //!< External 32kHz crystal oscillator as PCK source clock
-  GENCLK_PCK_SRC_SLCK_BYPASS   = 2, //!< External 32kHz bypass oscillator as PCK source clock
-  GENCLK_PCK_SRC_MAINCK_4M_RC  = 3, //!< Internal 4MHz RC oscillator as PCK source clock
-  GENCLK_PCK_SRC_MAINCK_8M_RC  = 4, //!< Internal 8MHz RC oscillator as PCK source clock
-  GENCLK_PCK_SRC_MAINCK_12M_RC = 5, //!< Internal 12MHz RC oscillator as PCK source clock
-  GENCLK_PCK_SRC_MAINCK_XTAL   = 6, //!< External crystal oscillator as PCK source clock
-  GENCLK_PCK_SRC_MAINCK_BYPASS = 7, //!< External bypass oscillator as PCK source clock
-  GENCLK_PCK_SRC_PLLACK        = 8, //!< Use PLLACK as PCK source clock
-  GENCLK_PCK_SRC_PLLBCK        = 9, //!< Use PLLBCK as PCK source clock
-  GENCLK_PCK_SRC_MCK           = 10, //!< Use Master Clk as PCK source clock
+	GENCLK_PCK_SRC_SLCK_RC       = 0, //!< Internal 32kHz RC oscillator as PCK source clock
+	GENCLK_PCK_SRC_SLCK_XTAL     = 1, //!< External 32kHz crystal oscillator as PCK source clock
+	GENCLK_PCK_SRC_SLCK_BYPASS   = 2, //!< External 32kHz bypass oscillator as PCK source clock
+	GENCLK_PCK_SRC_MAINCK_4M_RC  = 3, //!< Internal 4MHz RC oscillator as PCK source clock
+	GENCLK_PCK_SRC_MAINCK_8M_RC  = 4, //!< Internal 8MHz RC oscillator as PCK source clock
+	GENCLK_PCK_SRC_MAINCK_12M_RC = 5, //!< Internal 12MHz RC oscillator as PCK source clock
+	GENCLK_PCK_SRC_MAINCK_XTAL   = 6, //!< External crystal oscillator as PCK source clock
+	GENCLK_PCK_SRC_MAINCK_BYPASS = 7, //!< External bypass oscillator as PCK source clock
+	GENCLK_PCK_SRC_PLLACK        = 8, //!< Use PLLACK as PCK source clock
+	GENCLK_PCK_SRC_PLLBCK        = 9, //!< Use PLLBCK as PCK source clock
+	GENCLK_PCK_SRC_MCK           = 10, //!< Use Master Clk as PCK source clock
 };

 //@}
@@ -93,162 +93,176 @@ enum genclk_source {
 //@{

 enum genclk_divider {
-  GENCLK_PCK_PRES_1  = PMC_PCK_PRES_CLK_1, //!< Set PCK clock prescaler to 1
-  GENCLK_PCK_PRES_2  = PMC_PCK_PRES_CLK_2, //!< Set PCK clock prescaler to 2
-  GENCLK_PCK_PRES_4  = PMC_PCK_PRES_CLK_4, //!< Set PCK clock prescaler to 4
-  GENCLK_PCK_PRES_8  = PMC_PCK_PRES_CLK_8, //!< Set PCK clock prescaler to 8
-  GENCLK_PCK_PRES_16 = PMC_PCK_PRES_CLK_16, //!< Set PCK clock prescaler to 16
-  GENCLK_PCK_PRES_32 = PMC_PCK_PRES_CLK_32, //!< Set PCK clock prescaler to 32
-  GENCLK_PCK_PRES_64 = PMC_PCK_PRES_CLK_64, //!< Set PCK clock prescaler to 64
+	GENCLK_PCK_PRES_1  = PMC_PCK_PRES_CLK_1, //!< Set PCK clock prescaler to 1
+	GENCLK_PCK_PRES_2  = PMC_PCK_PRES_CLK_2, //!< Set PCK clock prescaler to 2
+	GENCLK_PCK_PRES_4  = PMC_PCK_PRES_CLK_4, //!< Set PCK clock prescaler to 4
+	GENCLK_PCK_PRES_8  = PMC_PCK_PRES_CLK_8, //!< Set PCK clock prescaler to 8
+	GENCLK_PCK_PRES_16 = PMC_PCK_PRES_CLK_16, //!< Set PCK clock prescaler to 16
+	GENCLK_PCK_PRES_32 = PMC_PCK_PRES_CLK_32, //!< Set PCK clock prescaler to 32
+	GENCLK_PCK_PRES_64 = PMC_PCK_PRES_CLK_64, //!< Set PCK clock prescaler to 64
 };

 //@}

 struct genclk_config {
-  uint32_t ctrl;
+	uint32_t ctrl;
 };

-static inline void genclk_config_defaults(struct genclk_config *p_cfg, uint32_t ul_id) {
-  ul_id = ul_id;
-  p_cfg->ctrl = 0;
+static inline void genclk_config_defaults(struct genclk_config *p_cfg,
+		uint32_t ul_id)
+{
+	ul_id = ul_id;
+	p_cfg->ctrl = 0;
 }

-static inline void genclk_config_read(struct genclk_config *p_cfg, uint32_t ul_id) {
-  p_cfg->ctrl = PMC->PMC_PCK[ul_id];
+static inline void genclk_config_read(struct genclk_config *p_cfg,
+		uint32_t ul_id)
+{
+	p_cfg->ctrl = PMC->PMC_PCK[ul_id];
 }

-static inline void genclk_config_write(const struct genclk_config *p_cfg, uint32_t ul_id) {
-  PMC->PMC_PCK[ul_id] = p_cfg->ctrl;
+static inline void genclk_config_write(const struct genclk_config *p_cfg,
+		uint32_t ul_id)
+{
+	PMC->PMC_PCK[ul_id] = p_cfg->ctrl;
 }

 //! \name Programmable Clock Source and Prescaler configuration
 //@{

-static inline void genclk_config_set_source(struct genclk_config *p_cfg, enum genclk_source e_src) {
-  p_cfg->ctrl &= (~PMC_PCK_CSS_Msk);
+static inline void genclk_config_set_source(struct genclk_config *p_cfg,
+		enum genclk_source e_src)
+{
+	p_cfg->ctrl &= (~PMC_PCK_CSS_Msk);

-  switch (e_src) {
-  case GENCLK_PCK_SRC_SLCK_RC:
-  case GENCLK_PCK_SRC_SLCK_XTAL:
-  case GENCLK_PCK_SRC_SLCK_BYPASS:
-    p_cfg->ctrl |= (PMC_PCK_CSS_SLOW_CLK);
-    break;
+	switch (e_src) {
+	case GENCLK_PCK_SRC_SLCK_RC:
+	case GENCLK_PCK_SRC_SLCK_XTAL:
+	case GENCLK_PCK_SRC_SLCK_BYPASS:
+		p_cfg->ctrl |= (PMC_PCK_CSS_SLOW_CLK);
+		break;

-  case GENCLK_PCK_SRC_MAINCK_4M_RC:
-  case GENCLK_PCK_SRC_MAINCK_8M_RC:
-  case GENCLK_PCK_SRC_MAINCK_12M_RC:
-  case GENCLK_PCK_SRC_MAINCK_XTAL:
-  case GENCLK_PCK_SRC_MAINCK_BYPASS:
-    p_cfg->ctrl |= (PMC_PCK_CSS_MAIN_CLK);
-    break;
+	case GENCLK_PCK_SRC_MAINCK_4M_RC:
+	case GENCLK_PCK_SRC_MAINCK_8M_RC:
+	case GENCLK_PCK_SRC_MAINCK_12M_RC:
+	case GENCLK_PCK_SRC_MAINCK_XTAL:
+	case GENCLK_PCK_SRC_MAINCK_BYPASS:
+		p_cfg->ctrl |= (PMC_PCK_CSS_MAIN_CLK);
+		break;

-  case GENCLK_PCK_SRC_PLLACK:
-    p_cfg->ctrl |= (PMC_PCK_CSS_PLLA_CLK);
-    break;
+	case GENCLK_PCK_SRC_PLLACK:
+		p_cfg->ctrl |= (PMC_PCK_CSS_PLLA_CLK);
+		break;

-  case GENCLK_PCK_SRC_PLLBCK:
-    p_cfg->ctrl |= (PMC_PCK_CSS_UPLL_CLK);
-    break;
+	case GENCLK_PCK_SRC_PLLBCK:
+		p_cfg->ctrl |= (PMC_PCK_CSS_UPLL_CLK);
+		break;

-  case GENCLK_PCK_SRC_MCK:
-    p_cfg->ctrl |= (PMC_PCK_CSS_MCK);
-    break;
-  }
+	case GENCLK_PCK_SRC_MCK:
+		p_cfg->ctrl |= (PMC_PCK_CSS_MCK);
+		break;
+	}
 }

-static inline void genclk_config_set_divider(struct genclk_config *p_cfg, uint32_t e_divider) {
-  p_cfg->ctrl &= ~PMC_PCK_PRES_Msk;
-  p_cfg->ctrl |= e_divider;
+static inline void genclk_config_set_divider(struct genclk_config *p_cfg,
+		uint32_t e_divider)
+{
+	p_cfg->ctrl &= ~PMC_PCK_PRES_Msk;
+	p_cfg->ctrl |= e_divider;
 }

 //@}

-static inline void genclk_enable(const struct genclk_config *p_cfg, uint32_t ul_id) {
-  PMC->PMC_PCK[ul_id] = p_cfg->ctrl;
-  pmc_enable_pck(ul_id);
+static inline void genclk_enable(const struct genclk_config *p_cfg,
+		uint32_t ul_id)
+{
+	PMC->PMC_PCK[ul_id] = p_cfg->ctrl;
+	pmc_enable_pck(ul_id);
 }

-static inline void genclk_disable(uint32_t ul_id) {
-  pmc_disable_pck(ul_id);
+static inline void genclk_disable(uint32_t ul_id)
+{
+	pmc_disable_pck(ul_id);
 }

-static inline void genclk_enable_source(enum genclk_source e_src) {
-  switch (e_src) {
-  case GENCLK_PCK_SRC_SLCK_RC:
-    if (!osc_is_ready(OSC_SLCK_32K_RC)) {
-      osc_enable(OSC_SLCK_32K_RC);
-      osc_wait_ready(OSC_SLCK_32K_RC);
-    }
-    break;
+static inline void genclk_enable_source(enum genclk_source e_src)
+{
+	switch (e_src) {
+	case GENCLK_PCK_SRC_SLCK_RC:
+		if (!osc_is_ready(OSC_SLCK_32K_RC)) {
+			osc_enable(OSC_SLCK_32K_RC);
+			osc_wait_ready(OSC_SLCK_32K_RC);
+		}
+		break;

-  case GENCLK_PCK_SRC_SLCK_XTAL:
-    if (!osc_is_ready(OSC_SLCK_32K_XTAL)) {
-      osc_enable(OSC_SLCK_32K_XTAL);
-      osc_wait_ready(OSC_SLCK_32K_XTAL);
-    }
-    break;
+	case GENCLK_PCK_SRC_SLCK_XTAL:
+		if (!osc_is_ready(OSC_SLCK_32K_XTAL)) {
+			osc_enable(OSC_SLCK_32K_XTAL);
+			osc_wait_ready(OSC_SLCK_32K_XTAL);
+		}
+		break;

-  case GENCLK_PCK_SRC_SLCK_BYPASS:
-    if (!osc_is_ready(OSC_SLCK_32K_BYPASS)) {
-      osc_enable(OSC_SLCK_32K_BYPASS);
-      osc_wait_ready(OSC_SLCK_32K_BYPASS);
-    }
-    break;
+	case GENCLK_PCK_SRC_SLCK_BYPASS:
+		if (!osc_is_ready(OSC_SLCK_32K_BYPASS)) {
+			osc_enable(OSC_SLCK_32K_BYPASS);
+			osc_wait_ready(OSC_SLCK_32K_BYPASS);
+		}
+		break;

-  case GENCLK_PCK_SRC_MAINCK_4M_RC:
-    if (!osc_is_ready(OSC_MAINCK_4M_RC)) {
-      osc_enable(OSC_MAINCK_4M_RC);
-      osc_wait_ready(OSC_MAINCK_4M_RC);
-    }
-    break;
+	case GENCLK_PCK_SRC_MAINCK_4M_RC:
+		if (!osc_is_ready(OSC_MAINCK_4M_RC)) {
+			osc_enable(OSC_MAINCK_4M_RC);
+			osc_wait_ready(OSC_MAINCK_4M_RC);
+		}
+		break;

-  case GENCLK_PCK_SRC_MAINCK_8M_RC:
-    if (!osc_is_ready(OSC_MAINCK_8M_RC)) {
-      osc_enable(OSC_MAINCK_8M_RC);
-      osc_wait_ready(OSC_MAINCK_8M_RC);
-    }
-    break;
+	case GENCLK_PCK_SRC_MAINCK_8M_RC:
+		if (!osc_is_ready(OSC_MAINCK_8M_RC)) {
+			osc_enable(OSC_MAINCK_8M_RC);
+			osc_wait_ready(OSC_MAINCK_8M_RC);
+		}
+		break;

-  case GENCLK_PCK_SRC_MAINCK_12M_RC:
-    if (!osc_is_ready(OSC_MAINCK_12M_RC)) {
-      osc_enable(OSC_MAINCK_12M_RC);
-      osc_wait_ready(OSC_MAINCK_12M_RC);
-    }
-    break;
+	case GENCLK_PCK_SRC_MAINCK_12M_RC:
+		if (!osc_is_ready(OSC_MAINCK_12M_RC)) {
+			osc_enable(OSC_MAINCK_12M_RC);
+			osc_wait_ready(OSC_MAINCK_12M_RC);
+		}
+		break;

-  case GENCLK_PCK_SRC_MAINCK_XTAL:
-    if (!osc_is_ready(OSC_MAINCK_XTAL)) {
-      osc_enable(OSC_MAINCK_XTAL);
-      osc_wait_ready(OSC_MAINCK_XTAL);
-    }
-    break;
+	case GENCLK_PCK_SRC_MAINCK_XTAL:
+		if (!osc_is_ready(OSC_MAINCK_XTAL)) {
+			osc_enable(OSC_MAINCK_XTAL);
+			osc_wait_ready(OSC_MAINCK_XTAL);
+		}
+		break;

-  case GENCLK_PCK_SRC_MAINCK_BYPASS:
-    if (!osc_is_ready(OSC_MAINCK_BYPASS)) {
-      osc_enable(OSC_MAINCK_BYPASS);
-      osc_wait_ready(OSC_MAINCK_BYPASS);
-    }
-    break;
+	case GENCLK_PCK_SRC_MAINCK_BYPASS:
+		if (!osc_is_ready(OSC_MAINCK_BYPASS)) {
+			osc_enable(OSC_MAINCK_BYPASS);
+			osc_wait_ready(OSC_MAINCK_BYPASS);
+		}
+		break;

-  #ifdef CONFIG_PLL0_SOURCE
-    case GENCLK_PCK_SRC_PLLACK:
-      pll_enable_config_defaults(0);
-      break;
-  #endif
+#ifdef CONFIG_PLL0_SOURCE
+	case GENCLK_PCK_SRC_PLLACK:
+		pll_enable_config_defaults(0);
+		break;
+#endif

-  #ifdef CONFIG_PLL1_SOURCE
-    case GENCLK_PCK_SRC_PLLBCK:
-      pll_enable_config_defaults(1);
-      break;
-  #endif
+#ifdef CONFIG_PLL1_SOURCE
+	case GENCLK_PCK_SRC_PLLBCK:
+		pll_enable_config_defaults(1);
+		break;
+#endif

-  case GENCLK_PCK_SRC_MCK:
-    break;
+	case GENCLK_PCK_SRC_MCK:
+		break;

-  default:
-    Assert(false);
-    break;
-  }
+	default:
+		Assert(false);
+		break;
+	}
 }

 //! @}
@@ -62,28 +62,28 @@ extern "C" {
 * should be defined by the board code, otherwise default value are used.
 */
 #ifndef BOARD_FREQ_SLCK_XTAL
-  #warning The board slow clock xtal frequency has not been defined.
-  #define BOARD_FREQ_SLCK_XTAL      (32768UL)
+#  warning The board slow clock xtal frequency has not been defined.
+#  define BOARD_FREQ_SLCK_XTAL      (32768UL)
 #endif

 #ifndef BOARD_FREQ_SLCK_BYPASS
-  #warning The board slow clock bypass frequency has not been defined.
-  #define BOARD_FREQ_SLCK_BYPASS    (32768UL)
+#  warning The board slow clock bypass frequency has not been defined.
+#  define BOARD_FREQ_SLCK_BYPASS    (32768UL)
 #endif

 #ifndef BOARD_FREQ_MAINCK_XTAL
-  #warning The board main clock xtal frequency has not been defined.
-  #define BOARD_FREQ_MAINCK_XTAL    (12000000UL)
+#  warning The board main clock xtal frequency has not been defined.
+#  define BOARD_FREQ_MAINCK_XTAL    (12000000UL)
 #endif

 #ifndef BOARD_FREQ_MAINCK_BYPASS
-  #warning The board main clock bypass frequency has not been defined.
-  #define BOARD_FREQ_MAINCK_BYPASS  (12000000UL)
+#  warning The board main clock bypass frequency has not been defined.
+#  define BOARD_FREQ_MAINCK_BYPASS  (12000000UL)
 #endif

 #ifndef BOARD_OSC_STARTUP_US
-  #warning The board main clock xtal startup time has not been defined.
-  #define BOARD_OSC_STARTUP_US      (15625UL)
+#  warning The board main clock xtal startup time has not been defined.
+#  define BOARD_OSC_STARTUP_US      (15625UL)
 #endif

 /**
@@ -115,118 +115,122 @@ extern "C" {
 #define OSC_MAINCK_BYPASS_HZ        BOARD_FREQ_MAINCK_BYPASS        //!< External bypass oscillator.
 //@}

-static inline void osc_enable(uint32_t ul_id) {
-  switch (ul_id) {
-  case OSC_SLCK_32K_RC:
-    break;
+static inline void osc_enable(uint32_t ul_id)
+{
+	switch (ul_id) {
+	case OSC_SLCK_32K_RC:
+		break;

-  case OSC_SLCK_32K_XTAL:
-    pmc_switch_sclk_to_32kxtal(PMC_OSC_XTAL);
-    break;
+	case OSC_SLCK_32K_XTAL:
+		pmc_switch_sclk_to_32kxtal(PMC_OSC_XTAL);
+		break;

-  case OSC_SLCK_32K_BYPASS:
-    pmc_switch_sclk_to_32kxtal(PMC_OSC_BYPASS);
-    break;
+	case OSC_SLCK_32K_BYPASS:
+		pmc_switch_sclk_to_32kxtal(PMC_OSC_BYPASS);
+		break;


-  case OSC_MAINCK_4M_RC:
-    pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_4_MHz);
-    break;
+	case OSC_MAINCK_4M_RC:
+		pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_4_MHz);
+		break;

-  case OSC_MAINCK_8M_RC:
-    pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_8_MHz);
-    break;
+	case OSC_MAINCK_8M_RC:
+		pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_8_MHz);
+		break;

-  case OSC_MAINCK_12M_RC:
-    pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_12_MHz);
-    break;
+	case OSC_MAINCK_12M_RC:
+		pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_12_MHz);
+		break;


-  case OSC_MAINCK_XTAL:
-    pmc_switch_mainck_to_xtal(PMC_OSC_XTAL/*,
-      pmc_us_to_moscxtst(BOARD_OSC_STARTUP_US,
-        OSC_SLCK_32K_RC_HZ)*/);
-    break;
+	case OSC_MAINCK_XTAL:
+		pmc_switch_mainck_to_xtal(PMC_OSC_XTAL/*,
+			pmc_us_to_moscxtst(BOARD_OSC_STARTUP_US,
+				OSC_SLCK_32K_RC_HZ)*/);
+		break;

-  case OSC_MAINCK_BYPASS:
-    pmc_switch_mainck_to_xtal(PMC_OSC_BYPASS/*,
-      pmc_us_to_moscxtst(BOARD_OSC_STARTUP_US,
-        OSC_SLCK_32K_RC_HZ)*/);
-    break;
-  }
+	case OSC_MAINCK_BYPASS:
+		pmc_switch_mainck_to_xtal(PMC_OSC_BYPASS/*,
+			pmc_us_to_moscxtst(BOARD_OSC_STARTUP_US,
+				OSC_SLCK_32K_RC_HZ)*/);
+		break;
+	}
 }

-static inline void osc_disable(uint32_t ul_id) {
-  switch (ul_id) {
-  case OSC_SLCK_32K_RC:
-  case OSC_SLCK_32K_XTAL:
-  case OSC_SLCK_32K_BYPASS:
-    break;
+static inline void osc_disable(uint32_t ul_id)
+{
+	switch (ul_id) {
+	case OSC_SLCK_32K_RC:
+	case OSC_SLCK_32K_XTAL:
+	case OSC_SLCK_32K_BYPASS:
+		break;

-  case OSC_MAINCK_4M_RC:
-  case OSC_MAINCK_8M_RC:
-  case OSC_MAINCK_12M_RC:
-    pmc_osc_disable_fastrc();
-    break;
+	case OSC_MAINCK_4M_RC:
+	case OSC_MAINCK_8M_RC:
+	case OSC_MAINCK_12M_RC:
+		pmc_osc_disable_fastrc();
+		break;

-  case OSC_MAINCK_XTAL:
-    pmc_osc_disable_xtal(PMC_OSC_XTAL);
-    break;
+	case OSC_MAINCK_XTAL:
+		pmc_osc_disable_xtal(PMC_OSC_XTAL);
+		break;

-  case OSC_MAINCK_BYPASS:
-    pmc_osc_disable_xtal(PMC_OSC_BYPASS);
-    break;
-  }
+	case OSC_MAINCK_BYPASS:
+		pmc_osc_disable_xtal(PMC_OSC_BYPASS);
+		break;
+	}
 }

-static inline bool osc_is_ready(uint32_t ul_id) {
-  switch (ul_id) {
-  case OSC_SLCK_32K_RC:
-    return 1;
+static inline bool osc_is_ready(uint32_t ul_id)
+{
+	switch (ul_id) {
+	case OSC_SLCK_32K_RC:
+		return 1;

-  case OSC_SLCK_32K_XTAL:
-  case OSC_SLCK_32K_BYPASS:
-    return pmc_osc_is_ready_32kxtal();
+	case OSC_SLCK_32K_XTAL:
+	case OSC_SLCK_32K_BYPASS:
+		return pmc_osc_is_ready_32kxtal();

-  case OSC_MAINCK_4M_RC:
-  case OSC_MAINCK_8M_RC:
-  case OSC_MAINCK_12M_RC:
-  case OSC_MAINCK_XTAL:
-  case OSC_MAINCK_BYPASS:
-    return pmc_osc_is_ready_mainck();
-  }
+	case OSC_MAINCK_4M_RC:
+	case OSC_MAINCK_8M_RC:
+	case OSC_MAINCK_12M_RC:
+	case OSC_MAINCK_XTAL:
+	case OSC_MAINCK_BYPASS:
+		return pmc_osc_is_ready_mainck();
+	}

-  return 0;
+	return 0;
 }

-static inline uint32_t osc_get_rate(uint32_t ul_id) {
-  switch (ul_id) {
-  case OSC_SLCK_32K_RC:
-    return OSC_SLCK_32K_RC_HZ;
+static inline uint32_t osc_get_rate(uint32_t ul_id)
+{
+	switch (ul_id) {
+	case OSC_SLCK_32K_RC:
+		return OSC_SLCK_32K_RC_HZ;

-  case OSC_SLCK_32K_XTAL:
-    return BOARD_FREQ_SLCK_XTAL;
+	case OSC_SLCK_32K_XTAL:
+		return BOARD_FREQ_SLCK_XTAL;

-  case OSC_SLCK_32K_BYPASS:
-    return BOARD_FREQ_SLCK_BYPASS;
+	case OSC_SLCK_32K_BYPASS:
+		return BOARD_FREQ_SLCK_BYPASS;

-  case OSC_MAINCK_4M_RC:
-    return OSC_MAINCK_4M_RC_HZ;
+	case OSC_MAINCK_4M_RC:
+		return OSC_MAINCK_4M_RC_HZ;

-  case OSC_MAINCK_8M_RC:
-    return OSC_MAINCK_8M_RC_HZ;
+	case OSC_MAINCK_8M_RC:
+		return OSC_MAINCK_8M_RC_HZ;

-  case OSC_MAINCK_12M_RC:
-    return OSC_MAINCK_12M_RC_HZ;
+	case OSC_MAINCK_12M_RC:
+		return OSC_MAINCK_12M_RC_HZ;

-  case OSC_MAINCK_XTAL:
-    return BOARD_FREQ_MAINCK_XTAL;
+	case OSC_MAINCK_XTAL:
+		return BOARD_FREQ_MAINCK_XTAL;

-  case OSC_MAINCK_BYPASS:
-    return BOARD_FREQ_MAINCK_BYPASS;
-  }
+	case OSC_MAINCK_BYPASS:
+		return BOARD_FREQ_MAINCK_BYPASS;
+	}

-  return 0;
+	return 0;
 }

 /**
@@ -237,10 +241,11 @@ static inline uint32_t osc_get_rate(uint32_t ul_id) {
 *
 * \param id A number identifying the oscillator to wait for.
 */
-static inline void osc_wait_ready(uint8_t id) {
-  while (!osc_is_ready(id)) {
-    /* Do nothing */
-  }
+static inline void osc_wait_ready(uint8_t id)
+{
+	while (!osc_is_ready(id)) {
+		/* Do nothing */
+	}
 }

 //! @}
@@ -77,22 +77,22 @@ extern "C" {
 #define PLL_COUNT           0x3FU

 enum pll_source {
-  PLL_SRC_MAINCK_4M_RC        = OSC_MAINCK_4M_RC,     //!< Internal 4MHz RC oscillator.
-  PLL_SRC_MAINCK_8M_RC        = OSC_MAINCK_8M_RC,     //!< Internal 8MHz RC oscillator.
-  PLL_SRC_MAINCK_12M_RC       = OSC_MAINCK_12M_RC,    //!< Internal 12MHz RC oscillator.
-  PLL_SRC_MAINCK_XTAL         = OSC_MAINCK_XTAL,      //!< External crystal oscillator.
-  PLL_SRC_MAINCK_BYPASS       = OSC_MAINCK_BYPASS,    //!< External bypass oscillator.
-  PLL_NR_SOURCES,                                     //!< Number of PLL sources.
+	PLL_SRC_MAINCK_4M_RC        = OSC_MAINCK_4M_RC,     //!< Internal 4MHz RC oscillator.
+	PLL_SRC_MAINCK_8M_RC        = OSC_MAINCK_8M_RC,     //!< Internal 8MHz RC oscillator.
+	PLL_SRC_MAINCK_12M_RC       = OSC_MAINCK_12M_RC,    //!< Internal 12MHz RC oscillator.
+	PLL_SRC_MAINCK_XTAL         = OSC_MAINCK_XTAL,      //!< External crystal oscillator.
+	PLL_SRC_MAINCK_BYPASS       = OSC_MAINCK_BYPASS,    //!< External bypass oscillator.
+	PLL_NR_SOURCES,                                     //!< Number of PLL sources.
 };

 struct pll_config {
-  uint32_t ctrl;
+	uint32_t ctrl;
 };

 #define pll_get_default_rate(pll_id)                                       \
-  ((osc_get_rate(CONFIG_PLL##pll_id##_SOURCE)                            \
-      * CONFIG_PLL##pll_id##_MUL)                                    \
-      / CONFIG_PLL##pll_id##_DIV)
+	((osc_get_rate(CONFIG_PLL##pll_id##_SOURCE)                            \
+			* CONFIG_PLL##pll_id##_MUL)                                    \
+			/ CONFIG_PLL##pll_id##_DIV)

 /* Force UTMI PLL parameters (Hardware defined) */
 #ifdef CONFIG_PLL1_SOURCE
@@ -113,130 +113,145 @@ struct pll_config {
 * is hidden in this implementation. Use mul as mul effective value.
 */
 static inline void pll_config_init(struct pll_config *p_cfg,
-    enum pll_source e_src, uint32_t ul_div, uint32_t ul_mul) {
-  uint32_t vco_hz;
+		enum pll_source e_src, uint32_t ul_div, uint32_t ul_mul)
+{
+	uint32_t vco_hz;

-  Assert(e_src < PLL_NR_SOURCES);
+	Assert(e_src < PLL_NR_SOURCES);

-  if (ul_div == 0 && ul_mul == 0) { /* Must only be true for UTMI PLL */
-    p_cfg->ctrl = CKGR_UCKR_UPLLCOUNT(PLL_COUNT);
-  }
-  else { /* PLLA */
-    /* Calculate internal VCO frequency */
-    vco_hz = osc_get_rate(e_src) / ul_div;
-    Assert(vco_hz >= PLL_INPUT_MIN_HZ);
-    Assert(vco_hz <= PLL_INPUT_MAX_HZ);
+	if (ul_div == 0 && ul_mul == 0) { /* Must only be true for UTMI PLL */
+		p_cfg->ctrl = CKGR_UCKR_UPLLCOUNT(PLL_COUNT);
+	} else { /* PLLA */
+		/* Calculate internal VCO frequency */
+		vco_hz = osc_get_rate(e_src) / ul_div;
+		Assert(vco_hz >= PLL_INPUT_MIN_HZ);
+		Assert(vco_hz <= PLL_INPUT_MAX_HZ);

-    vco_hz *= ul_mul;
-    Assert(vco_hz >= PLL_OUTPUT_MIN_HZ);
-    Assert(vco_hz <= PLL_OUTPUT_MAX_HZ);
+		vco_hz *= ul_mul;
+		Assert(vco_hz >= PLL_OUTPUT_MIN_HZ);
+		Assert(vco_hz <= PLL_OUTPUT_MAX_HZ);

-    /* PMC hardware will automatically make it mul+1 */
-    p_cfg->ctrl = CKGR_PLLAR_MULA(ul_mul - 1) | CKGR_PLLAR_DIVA(ul_div) | CKGR_PLLAR_PLLACOUNT(PLL_COUNT);
-  }
+		/* PMC hardware will automatically make it mul+1 */
+		p_cfg->ctrl = CKGR_PLLAR_MULA(ul_mul - 1) | CKGR_PLLAR_DIVA(ul_div) | CKGR_PLLAR_PLLACOUNT(PLL_COUNT);
+	}
 }

-#define pll_config_defaults(cfg, pll_id)  \
-  pll_config_init(cfg,                    \
-      CONFIG_PLL##pll_id##_SOURCE,        \
-      CONFIG_PLL##pll_id##_DIV,           \
-      CONFIG_PLL##pll_id##_MUL)
+#define pll_config_defaults(cfg, pll_id)                                   \
+	pll_config_init(cfg,                                                   \
+			CONFIG_PLL##pll_id##_SOURCE,                                   \
+			CONFIG_PLL##pll_id##_DIV,                                      \
+			CONFIG_PLL##pll_id##_MUL)

-static inline void pll_config_read(struct pll_config *p_cfg, uint32_t ul_pll_id) {
-  Assert(ul_pll_id < NR_PLLS);
-  p_cfg->ctrl = ul_pll_id == PLLA_ID ? PMC->CKGR_PLLAR : PMC->CKGR_UCKR;
+static inline void pll_config_read(struct pll_config *p_cfg, uint32_t ul_pll_id)
+{
+	Assert(ul_pll_id < NR_PLLS);
+
+	if (ul_pll_id == PLLA_ID) {
+		p_cfg->ctrl = PMC->CKGR_PLLAR;
+	} else {
+		p_cfg->ctrl = PMC->CKGR_UCKR;
+	}
 }

-static inline void pll_config_write(const struct pll_config *p_cfg, uint32_t ul_pll_id) {
-  Assert(ul_pll_id < NR_PLLS);
+static inline void pll_config_write(const struct pll_config *p_cfg, uint32_t ul_pll_id)
+{
+	Assert(ul_pll_id < NR_PLLS);

-  if (ul_pll_id == PLLA_ID) {
-    pmc_disable_pllack(); // Always stop PLL first!
-    PMC->CKGR_PLLAR = CKGR_PLLAR_ONE | p_cfg->ctrl;
-  }
-  else
-    PMC->CKGR_UCKR = p_cfg->ctrl;
+	if (ul_pll_id == PLLA_ID) {
+		pmc_disable_pllack(); // Always stop PLL first!
+		PMC->CKGR_PLLAR = CKGR_PLLAR_ONE | p_cfg->ctrl;
+	} else {
+		PMC->CKGR_UCKR = p_cfg->ctrl;
+	}
 }

-static inline void pll_enable(const struct pll_config *p_cfg, uint32_t ul_pll_id) {
-  Assert(ul_pll_id < NR_PLLS);
+static inline void pll_enable(const struct pll_config *p_cfg, uint32_t ul_pll_id)
+{
+	Assert(ul_pll_id < NR_PLLS);

-  if (ul_pll_id == PLLA_ID) {
-    pmc_disable_pllack(); // Always stop PLL first!
-    PMC->CKGR_PLLAR = CKGR_PLLAR_ONE | p_cfg->ctrl;
-  }
-  else
-    PMC->CKGR_UCKR = p_cfg->ctrl | CKGR_UCKR_UPLLEN;
+	if (ul_pll_id == PLLA_ID) {
+		pmc_disable_pllack(); // Always stop PLL first!
+		PMC->CKGR_PLLAR = CKGR_PLLAR_ONE | p_cfg->ctrl;
+	} else {
+		PMC->CKGR_UCKR = p_cfg->ctrl | CKGR_UCKR_UPLLEN;
+	}
 }

 /**
 * \note This will only disable the selected PLL, not the underlying oscillator (mainck).
 */
-static inline void pll_disable(uint32_t ul_pll_id) {
-  Assert(ul_pll_id < NR_PLLS);
+static inline void pll_disable(uint32_t ul_pll_id)
+{
+	Assert(ul_pll_id < NR_PLLS);

-  if (ul_pll_id == PLLA_ID)
-    pmc_disable_pllack();
-  else
-    PMC->CKGR_UCKR &= ~CKGR_UCKR_UPLLEN;
+	if (ul_pll_id == PLLA_ID) {
+		pmc_disable_pllack();
+	} else {
+		PMC->CKGR_UCKR &= ~CKGR_UCKR_UPLLEN;
+	}
 }

-static inline uint32_t pll_is_locked(uint32_t ul_pll_id) {
-  Assert(ul_pll_id < NR_PLLS);
+static inline uint32_t pll_is_locked(uint32_t ul_pll_id)
+{
+	Assert(ul_pll_id < NR_PLLS);

-  if (ul_pll_id == PLLA_ID)
-    return pmc_is_locked_pllack();
-  else
-    return pmc_is_locked_upll();
+	if (ul_pll_id == PLLA_ID) {
+		return pmc_is_locked_pllack();
+	} else {
+		return pmc_is_locked_upll();
+	}
 }

-static inline void pll_enable_source(enum pll_source e_src) {
-  switch (e_src) {
-  case PLL_SRC_MAINCK_4M_RC:
-  case PLL_SRC_MAINCK_8M_RC:
-  case PLL_SRC_MAINCK_12M_RC:
-  case PLL_SRC_MAINCK_XTAL:
-  case PLL_SRC_MAINCK_BYPASS:
-    osc_enable(e_src);
-    osc_wait_ready(e_src);
-    break;
+static inline void pll_enable_source(enum pll_source e_src)
+{
+	switch (e_src) {
+	case PLL_SRC_MAINCK_4M_RC:
+	case PLL_SRC_MAINCK_8M_RC:
+	case PLL_SRC_MAINCK_12M_RC:
+	case PLL_SRC_MAINCK_XTAL:
+	case PLL_SRC_MAINCK_BYPASS:
+		osc_enable(e_src);
+		osc_wait_ready(e_src);
+		break;

-  default:
-    Assert(false);
-    break;
-  }
+	default:
+		Assert(false);
+		break;
+	}
 }

-static inline void pll_enable_config_defaults(unsigned int ul_pll_id) {
-  struct pll_config pllcfg;
+static inline void pll_enable_config_defaults(unsigned int ul_pll_id)
+{
+	struct pll_config pllcfg;

-  if (pll_is_locked(ul_pll_id)) return; // Pll already running
-
-  switch (ul_pll_id) {
-    #ifdef CONFIG_PLL0_SOURCE
-      case 0:
-        pll_enable_source(CONFIG_PLL0_SOURCE);
-        pll_config_init(&pllcfg,
-            CONFIG_PLL0_SOURCE,
-            CONFIG_PLL0_DIV,
-            CONFIG_PLL0_MUL);
-        break;
-    #endif
-    #ifdef CONFIG_PLL1_SOURCE
-      case 1:
-        pll_enable_source(CONFIG_PLL1_SOURCE);
-        pll_config_init(&pllcfg,
-            CONFIG_PLL1_SOURCE,
-            CONFIG_PLL1_DIV,
-            CONFIG_PLL1_MUL);
-        break;
-    #endif
-    default:
-      Assert(false);
-      break;
-  }
-  pll_enable(&pllcfg, ul_pll_id);
-  while (!pll_is_locked(ul_pll_id));
+	if (pll_is_locked(ul_pll_id)) {
+		return; // Pll already running
+	}
+	switch (ul_pll_id) {
+#ifdef CONFIG_PLL0_SOURCE
+	case 0:
+		pll_enable_source(CONFIG_PLL0_SOURCE);
+		pll_config_init(&pllcfg,
+				CONFIG_PLL0_SOURCE,
+				CONFIG_PLL0_DIV,
+				CONFIG_PLL0_MUL);
+		break;
+#endif
+#ifdef CONFIG_PLL1_SOURCE
+	case 1:
+		pll_enable_source(CONFIG_PLL1_SOURCE);
+		pll_config_init(&pllcfg,
+				CONFIG_PLL1_SOURCE,
+				CONFIG_PLL1_DIV,
+				CONFIG_PLL1_MUL);
+		break;
+#endif
+	default:
+		Assert(false);
+		break;
+	}
+	pll_enable(&pllcfg, ul_pll_id);
+	while (!pll_is_locked(ul_pll_id));
 }

 /**
@@ -249,12 +264,15 @@ static inline void pll_enable_config_defaults(unsigned int ul_pll_id) {
 * \retval STATUS_OK The PLL is now locked.
 * \retval ERR_TIMEOUT Timed out waiting for PLL to become locked.
 */
-static inline int pll_wait_for_lock(unsigned int pll_id) {
-  Assert(pll_id < NR_PLLS);
+static inline int pll_wait_for_lock(unsigned int pll_id)
+{
+	Assert(pll_id < NR_PLLS);

-  while (!pll_is_locked(pll_id)) { /* Do nothing */ }
+	while (!pll_is_locked(pll_id)) {
+		/* Do nothing */
+	}

-  return 0;
+	return 0;
 }

 //! @}
@@ -57,6 +57,7 @@
 #ifndef _SBC_PROTOCOL_H_
 #define _SBC_PROTOCOL_H_

+
 /**
 * \ingroup usb_msc_protocol
 * \defgroup usb_sbc_protocol SCSI Block Commands protocol definitions
@@ -80,82 +81,82 @@
 //@{

 enum scsi_sbc_mode {
-  SCSI_MS_MODE_RW_ERR_RECOV = 0x01,   //!< Read-Write Error Recovery mode page
-  SCSI_MS_MODE_FORMAT_DEVICE = 0x03,  //!< Format Device mode page
-  SCSI_MS_MODE_FLEXIBLE_DISK = 0x05,  //!< Flexible Disk mode page
-  SCSI_MS_MODE_CACHING = 0x08,    //!< Caching mode page
+	SCSI_MS_MODE_RW_ERR_RECOV = 0x01,	//!< Read-Write Error Recovery mode page
+	SCSI_MS_MODE_FORMAT_DEVICE = 0x03,	//!< Format Device mode page
+	SCSI_MS_MODE_FLEXIBLE_DISK = 0x05,	//!< Flexible Disk mode page
+	SCSI_MS_MODE_CACHING = 0x08,	//!< Caching mode page
 };


 //! \name SBC-2 Device-Specific Parameter
 //@{
-#define SCSI_MS_SBC_WP              0x80    //!< Write Protected
-#define SCSI_MS_SBC_DPOFUA          0x10    //!< DPO and FUA supported
+#define SCSI_MS_SBC_WP              0x80	//!< Write Protected
+#define SCSI_MS_SBC_DPOFUA          0x10	//!< DPO and FUA supported
 //@}

 /**
 * \brief SBC-2 Short LBA mode parameter block descriptor
 */
 struct sbc_slba_block_desc {
-  be32_t nr_blocks;   //!< Number of Blocks
-  be32_t block_len;   //!< Block Length
-#define SBC_SLBA_BLOCK_LEN_MASK   0x00FFFFFFU   //!< Mask reserved bits
+	be32_t nr_blocks;	//!< Number of Blocks
+	be32_t block_len;	//!< Block Length
+#define SBC_SLBA_BLOCK_LEN_MASK   0x00FFFFFFU	//!< Mask reserved bits
 };

 /**
 * \brief SBC-2 Caching mode page
 */
 struct sbc_caching_mode_page {
-  uint8_t page_code;
-  uint8_t page_length;
-  uint8_t flags2;
-#define  SBC_MP_CACHE_IC      (1 << 7)  //!< Initiator Control
-#define  SBC_MP_CACHE_ABPF    (1 << 6)  //!< Abort Pre-Fetch
-#define  SBC_MP_CACHE_CAP     (1 << 5)  //!< Catching Analysis Permitted
-#define  SBC_MP_CACHE_DISC    (1 << 4)  //!< Discontinuity
-#define  SBC_MP_CACHE_SIZE    (1 << 3)  //!< Size enable
-#define  SBC_MP_CACHE_WCE     (1 << 2)  //!< Write back Cache Enable
-#define  SBC_MP_CACHE_MF      (1 << 1)  //!< Multiplication Factor
-#define  SBC_MP_CACHE_RCD     (1 << 0)  //!< Read Cache Disable
-  uint8_t retention;
-  be16_t dis_pf_transfer_len;
-  be16_t min_prefetch;
-  be16_t max_prefetch;
-  be16_t max_prefetch_ceil;
-  uint8_t flags12;
-#define  SBC_MP_CACHE_FSW     (1 << 7)  //!< Force Sequential Write
-#define  SBC_MP_CACHE_LBCSS   (1 << 6)  //!< Logical Blk Cache Seg Sz
-#define  SBC_MP_CACHE_DRA     (1 << 5)  //!< Disable Read-Ahead
-#define  SBC_MP_CACHE_NV_DIS  (1 << 0)  //!< Non-Volatile Cache Disable
-  uint8_t nr_cache_segments;
-  be16_t cache_segment_size;
-  uint8_t reserved[4];
+	uint8_t page_code;
+	uint8_t page_length;
+	uint8_t flags2;
+#define  SBC_MP_CACHE_IC      (1 << 7)	//!< Initiator Control
+#define  SBC_MP_CACHE_ABPF    (1 << 6)	//!< Abort Pre-Fetch
+#define  SBC_MP_CACHE_CAP     (1 << 5)	//!< Catching Analysis Permitted
+#define  SBC_MP_CACHE_DISC    (1 << 4)	//!< Discontinuity
+#define  SBC_MP_CACHE_SIZE    (1 << 3)	//!< Size enable
+#define  SBC_MP_CACHE_WCE     (1 << 2)	//!< Write back Cache Enable
+#define  SBC_MP_CACHE_MF      (1 << 1)	//!< Multiplication Factor
+#define  SBC_MP_CACHE_RCD     (1 << 0)	//!< Read Cache Disable
+	uint8_t retention;
+	be16_t dis_pf_transfer_len;
+	be16_t min_prefetch;
+	be16_t max_prefetch;
+	be16_t max_prefetch_ceil;
+	uint8_t flags12;
+#define  SBC_MP_CACHE_FSW     (1 << 7)	//!< Force Sequential Write
+#define  SBC_MP_CACHE_LBCSS   (1 << 6)	//!< Logical Blk Cache Seg Sz
+#define  SBC_MP_CACHE_DRA     (1 << 5)	//!< Disable Read-Ahead
+#define  SBC_MP_CACHE_NV_DIS  (1 << 0)	//!< Non-Volatile Cache Disable
+	uint8_t nr_cache_segments;
+	be16_t cache_segment_size;
+	uint8_t reserved[4];
 };

 /**
 * \brief SBC-2 Read-Write Error Recovery mode page
 */
 struct sbc_rdwr_error_recovery_mode_page {
-  uint8_t page_code;
-  uint8_t page_length;
-  #define  SPC_MP_RW_ERR_RECOV_PAGE_LENGTH    0x0A
-  uint8_t flags1;
-  #define  SBC_MP_RW_ERR_RECOV_AWRE   (1 << 7)
-  #define  SBC_MP_RW_ERR_RECOV_ARRE   (1 << 6)
-  #define  SBC_MP_RW_ERR_RECOV_TB     (1 << 5)
-  #define  SBC_MP_RW_ERR_RECOV_RC     (1 << 4)
-  #define  SBC_MP_RW_ERR_RECOV_ERR    (1 << 3)
-  #define  SBC_MP_RW_ERR_RECOV_PER    (1 << 2)
-  #define  SBC_MP_RW_ERR_RECOV_DTE    (1 << 1)
-  #define  SBC_MP_RW_ERR_RECOV_DCR    (1 << 0)
-  uint8_t read_retry_count;
-  uint8_t correction_span;
-  uint8_t head_offset_count;
-  uint8_t data_strobe_offset_count;
-  uint8_t flags2;
-  uint8_t write_retry_count;
-  uint8_t flags3;
-  be16_t recovery_time_limit;
+	uint8_t page_code;
+	uint8_t page_length;
+#define  SPC_MP_RW_ERR_RECOV_PAGE_LENGTH    0x0A
+	uint8_t flags1;
+#define  SBC_MP_RW_ERR_RECOV_AWRE   (1 << 7)
+#define  SBC_MP_RW_ERR_RECOV_ARRE   (1 << 6)
+#define  SBC_MP_RW_ERR_RECOV_TB     (1 << 5)
+#define  SBC_MP_RW_ERR_RECOV_RC     (1 << 4)
+#define  SBC_MP_RW_ERR_RECOV_ERR    (1 << 3)
+#define  SBC_MP_RW_ERR_RECOV_PER    (1 << 2)
+#define  SBC_MP_RW_ERR_RECOV_DTE    (1 << 1)
+#define  SBC_MP_RW_ERR_RECOV_DCR    (1 << 0)
+	uint8_t read_retry_count;
+	uint8_t correction_span;
+	uint8_t head_offset_count;
+	uint8_t data_strobe_offset_count;
+	uint8_t flags2;
+	uint8_t write_retry_count;
+	uint8_t flags3;
+	be16_t recovery_time_limit;
 };
 //@}

@@ -163,8 +164,8 @@ struct sbc_rdwr_error_recovery_mode_page {
 * \brief SBC-2 READ CAPACITY (10) parameter data
 */
 struct sbc_read_capacity10_data {
-  be32_t max_lba; //!< LBA of last logical block
-  be32_t block_len;   //!< Number of bytes in the last logical block
+	be32_t max_lba;	//!< LBA of last logical block
+	be32_t block_len;	//!< Number of bytes in the last logical block
 };

 //@}
@@ -6,7 +6,7 @@

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

-#if HAS_MEDIA
+#if ENABLED(SDSUPPORT)

 #include "../../../sd/cardreader.h"
 extern "C" {
@@ -138,5 +138,5 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {

 #endif // ACCESS_USB == true

-#endif // HAS_MEDIA
+#endif // SDSUPPORT
 #endif // ARDUINO_ARCH_SAM
@@ -59,23 +59,23 @@

 //! \name SCSI commands defined by SPC-2
 //@{
-#define SPC_TEST_UNIT_READY              0x00
-#define SPC_REQUEST_SENSE                0x03
-#define SPC_INQUIRY                      0x12
-#define SPC_MODE_SELECT6                 0x15
-#define SPC_MODE_SENSE6                  0x1A
-#define SPC_SEND_DIAGNOSTIC              0x1D
-#define SPC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1E
-#define SPC_MODE_SENSE10                 0x5A
-#define SPC_REPORT_LUNS                  0xA0
+#define  SPC_TEST_UNIT_READY              0x00
+#define  SPC_REQUEST_SENSE                0x03
+#define  SPC_INQUIRY                      0x12
+#define  SPC_MODE_SELECT6                 0x15
+#define  SPC_MODE_SENSE6                  0x1A
+#define  SPC_SEND_DIAGNOSTIC              0x1D
+#define  SPC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1E
+#define  SPC_MODE_SENSE10                 0x5A
+#define  SPC_REPORT_LUNS                  0xA0
 //@}

 //! \brief May be set in byte 0 of the INQUIRY CDB
 //@{
 //! Enable Vital Product Data
-#define SCSI_INQ_REQ_EVPD    0x01
+#define  SCSI_INQ_REQ_EVPD    0x01
 //! Command Support Data specified by the PAGE OR OPERATION CODE field
-#define SCSI_INQ_REQ_CMDT    0x02
+#define  SCSI_INQ_REQ_CMDT    0x02
 //@}

 COMPILER_PACK_SET(1)
@@ -84,110 +84,110 @@ COMPILER_PACK_SET(1)
 * \brief SCSI Standard Inquiry data structure
 */
 struct scsi_inquiry_data {
-  uint8_t pq_pdt; //!< Peripheral Qual / Peripheral Dev Type
-  #define SCSI_INQ_PQ_CONNECTED     0x00   //!< Peripheral connected
-  #define SCSI_INQ_PQ_NOT_CONN      0x20   //!< Peripheral not connected
-  #define SCSI_INQ_PQ_NOT_SUPP      0x60   //!< Peripheral not supported
-  #define SCSI_INQ_DT_DIR_ACCESS    0x00   //!< Direct Access (SBC)
-  #define SCSI_INQ_DT_SEQ_ACCESS    0x01   //!< Sequential Access
-  #define SCSI_INQ_DT_PRINTER       0x02   //!< Printer
-  #define SCSI_INQ_DT_PROCESSOR     0x03   //!< Processor device
-  #define SCSI_INQ_DT_WRITE_ONCE    0x04   //!< Write-once device
-  #define SCSI_INQ_DT_CD_DVD        0x05   //!< CD/DVD device
-  #define SCSI_INQ_DT_OPTICAL       0x07   //!< Optical Memory
-  #define SCSI_INQ_DT_MC            0x08   //!< Medium Changer
-  #define SCSI_INQ_DT_ARRAY         0x0C   //!< Storage Array Controller
-  #define SCSI_INQ_DT_ENCLOSURE     0x0D   //!< Enclosure Services
-  #define SCSI_INQ_DT_RBC           0x0E   //!< Simplified Direct Access
-  #define SCSI_INQ_DT_OCRW          0x0F   //!< Optical card reader/writer
-  #define SCSI_INQ_DT_BCC           0x10   //!< Bridge Controller Commands
-  #define SCSI_INQ_DT_OSD           0x11   //!< Object-based Storage
-  #define SCSI_INQ_DT_NONE          0x1F   //!< No Peripheral
-  uint8_t flags1; //!< Flags (byte 1)
-  #define SCSI_INQ_RMB              0x80   //!< Removable Medium
-  uint8_t version; //!< Version
-  #define SCSI_INQ_VER_NONE         0x00   //!< No standards conformance
-  #define SCSI_INQ_VER_SPC          0x03   //!< SCSI Primary Commands     (link to SBC)
-  #define SCSI_INQ_VER_SPC2         0x04   //!< SCSI Primary Commands - 2 (link to SBC-2)
-  #define SCSI_INQ_VER_SPC3         0x05   //!< SCSI Primary Commands - 3 (link to SBC-2)
-  #define SCSI_INQ_VER_SPC4         0x06   //!< SCSI Primary Commands - 4 (link to SBC-3)
-  uint8_t flags3; //!< Flags (byte 3)
-  #define SCSI_INQ_NORMACA          0x20   //!< Normal ACA Supported
-  #define SCSI_INQ_HISUP            0x10   //!< Hierarchal LUN addressing
-  #define SCSI_INQ_RSP_SPC2         0x02   //!< SPC-2 / SPC-3 response format
-  uint8_t addl_len; //!< Additional Length (n-4)
-  #define SCSI_INQ_ADDL_LEN(tot)  ((tot)-5) //!< Total length is \a tot
-  uint8_t flags5; //!< Flags (byte 5)
-  #define SCSI_INQ_SCCS             0x80
-  uint8_t flags6; //!< Flags (byte 6)
-  #define SCSI_INQ_BQUE             0x80
-  #define SCSI_INQ_ENCSERV          0x40
-  #define SCSI_INQ_MULTIP           0x10
-  #define SCSI_INQ_MCHGR            0x08
-  #define SCSI_INQ_ADDR16           0x01
-  uint8_t flags7; //!< Flags (byte 7)
-  #define SCSI_INQ_WBUS16           0x20
-  #define SCSI_INQ_SYNC             0x10
-  #define SCSI_INQ_LINKED           0x08
-  #define SCSI_INQ_CMDQUE           0x02
-  uint8_t vendor_id[8];   //!< T10 Vendor Identification
-  uint8_t product_id[16]; //!< Product Identification
-  uint8_t product_rev[4]; //!< Product Revision Level
+	uint8_t pq_pdt; //!< Peripheral Qual / Peripheral Dev Type
+#define  SCSI_INQ_PQ_CONNECTED   0x00   //!< Peripheral connected
+#define  SCSI_INQ_PQ_NOT_CONN    0x20   //!< Peripheral not connected
+#define  SCSI_INQ_PQ_NOT_SUPP    0x60   //!< Peripheral not supported
+#define  SCSI_INQ_DT_DIR_ACCESS  0x00   //!< Direct Access (SBC)
+#define  SCSI_INQ_DT_SEQ_ACCESS  0x01   //!< Sequential Access
+#define  SCSI_INQ_DT_PRINTER     0x02   //!< Printer
+#define  SCSI_INQ_DT_PROCESSOR   0x03   //!< Processor device
+#define  SCSI_INQ_DT_WRITE_ONCE  0x04   //!< Write-once device
+#define  SCSI_INQ_DT_CD_DVD      0x05   //!< CD/DVD device
+#define  SCSI_INQ_DT_OPTICAL     0x07   //!< Optical Memory
+#define  SCSI_INQ_DT_MC          0x08   //!< Medium Changer
+#define  SCSI_INQ_DT_ARRAY       0x0C   //!< Storage Array Controller
+#define  SCSI_INQ_DT_ENCLOSURE   0x0D   //!< Enclosure Services
+#define  SCSI_INQ_DT_RBC         0x0E   //!< Simplified Direct Access
+#define  SCSI_INQ_DT_OCRW        0x0F   //!< Optical card reader/writer
+#define  SCSI_INQ_DT_BCC         0x10   //!< Bridge Controller Commands
+#define  SCSI_INQ_DT_OSD         0x11   //!< Object-based Storage
+#define  SCSI_INQ_DT_NONE        0x1F   //!< No Peripheral
+	uint8_t flags1; //!< Flags (byte 1)
+#define  SCSI_INQ_RMB            0x80   //!< Removable Medium
+	uint8_t version; //!< Version
+#define  SCSI_INQ_VER_NONE       0x00   //!< No standards conformance
+#define  SCSI_INQ_VER_SPC        0x03   //!< SCSI Primary Commands     (link to SBC)
+#define  SCSI_INQ_VER_SPC2       0x04   //!< SCSI Primary Commands - 2 (link to SBC-2)
+#define  SCSI_INQ_VER_SPC3       0x05   //!< SCSI Primary Commands - 3 (link to SBC-2)
+#define  SCSI_INQ_VER_SPC4       0x06   //!< SCSI Primary Commands - 4 (link to SBC-3)
+	uint8_t flags3; //!< Flags (byte 3)
+#define  SCSI_INQ_NORMACA        0x20   //!< Normal ACA Supported
+#define  SCSI_INQ_HISUP          0x10   //!< Hierarchal LUN addressing
+#define  SCSI_INQ_RSP_SPC2       0x02   //!< SPC-2 / SPC-3 response format
+	uint8_t addl_len; //!< Additional Length (n-4)
+#define  SCSI_INQ_ADDL_LEN(tot)  ((tot)-5) //!< Total length is \a tot
+	uint8_t flags5; //!< Flags (byte 5)
+#define  SCSI_INQ_SCCS           0x80
+	uint8_t flags6; //!< Flags (byte 6)
+#define  SCSI_INQ_BQUE           0x80
+#define  SCSI_INQ_ENCSERV        0x40
+#define  SCSI_INQ_MULTIP         0x10
+#define  SCSI_INQ_MCHGR          0x08
+#define  SCSI_INQ_ADDR16         0x01
+	uint8_t flags7; //!< Flags (byte 7)
+#define  SCSI_INQ_WBUS16         0x20
+#define  SCSI_INQ_SYNC           0x10
+#define  SCSI_INQ_LINKED         0x08
+#define  SCSI_INQ_CMDQUE         0x02
+	uint8_t vendor_id[8];   //!< T10 Vendor Identification
+	uint8_t product_id[16]; //!< Product Identification
+	uint8_t product_rev[4]; //!< Product Revision Level
 };

 /**
 * \brief SCSI Standard Request sense data structure
 */
 struct scsi_request_sense_data {
-  /* 1st byte: REQUEST SENSE response flags*/
-  uint8_t valid_reponse_code;
-  #define SCSI_SENSE_VALID              0x80 //!< Indicates the INFORMATION field contains valid information
-  #define SCSI_SENSE_RESPONSE_CODE_MASK 0x7F
-  #define SCSI_SENSE_CURRENT            0x70 //!< Response code 70h (current errors)
-  #define SCSI_SENSE_DEFERRED           0x71
+	/* 1st byte: REQUEST SENSE response flags*/
+	uint8_t valid_reponse_code;
+#define  SCSI_SENSE_VALID              0x80 //!< Indicates the INFORMATION field contains valid information
+#define  SCSI_SENSE_RESPONSE_CODE_MASK 0x7F
+#define  SCSI_SENSE_CURRENT            0x70 //!< Response code 70h (current errors)
+#define  SCSI_SENSE_DEFERRED           0x71

-  /* 2nd byte */
-  uint8_t obsolete;
+	/* 2nd byte */
+	uint8_t obsolete;

-  /* 3rd byte */
-  uint8_t sense_flag_key;
-  #define SCSI_SENSE_FILEMARK        0x80 //!< Indicates that the current command has read a filemark or setmark.
-  #define SCSI_SENSE_EOM             0x40 //!< Indicates that an end-of-medium condition exists.
-  #define SCSI_SENSE_ILI             0x20 //!< Indicates that the requested logical block length did not match the logical block length of the data on the medium.
-  #define SCSI_SENSE_RESERVED        0x10 //!< Reserved
-  #define SCSI_SENSE_KEY(x)          (x&0x0F) //!< Sense Key
+	/* 3rd byte */
+	uint8_t sense_flag_key;
+#define  SCSI_SENSE_FILEMARK        0x80 //!< Indicates that the current command has read a filemark or setmark.
+#define  SCSI_SENSE_EOM             0x40 //!< Indicates that an end-of-medium condition exists.
+#define  SCSI_SENSE_ILI             0x20 //!< Indicates that the requested logical block length did not match the logical block length of the data on the medium.
+#define  SCSI_SENSE_RESERVED        0x10 //!< Reserved
+#define  SCSI_SENSE_KEY(x)          (x&0x0F) //!< Sense Key

-  /* 4th to 7th bytes - INFORMATION field */
-  uint8_t information[4];
+	/* 4th to 7th bytes - INFORMATION field */
+	uint8_t information[4];

-  /* 8th byte  - ADDITIONAL SENSE LENGTH field */
-  uint8_t AddSenseLen;
-  #define SCSI_SENSE_ADDL_LEN(total_len)   ((total_len) - 8)
+	/* 8th byte  - ADDITIONAL SENSE LENGTH field */
+	uint8_t AddSenseLen;
+#define  SCSI_SENSE_ADDL_LEN(total_len)   ((total_len) - 8)

-  /* 9th to 12th byte  - COMMAND-SPECIFIC INFORMATION field */
-  uint8_t CmdSpecINFO[4];
+	/* 9th to 12th byte  - COMMAND-SPECIFIC INFORMATION field */
+	uint8_t CmdSpecINFO[4];

-  /* 13th byte  - ADDITIONAL SENSE CODE field */
-  uint8_t AddSenseCode;
+	/* 13th byte  - ADDITIONAL SENSE CODE field */
+	uint8_t AddSenseCode;

-  /* 14th byte  - ADDITIONAL SENSE CODE QUALIFIER field */
-  uint8_t AddSnsCodeQlfr;
+	/* 14th byte  - ADDITIONAL SENSE CODE QUALIFIER field */
+	uint8_t AddSnsCodeQlfr;

-  /* 15th byte  - FIELD REPLACEABLE UNIT CODE field */
-  uint8_t FldReplUnitCode;
+	/* 15th byte  - FIELD REPLACEABLE UNIT CODE field */
+	uint8_t FldReplUnitCode;

-  /* 16th byte */
-  uint8_t SenseKeySpec[3];
-  #define SCSI_SENSE_SKSV            0x80 //!< Indicates the SENSE-KEY SPECIFIC field contains valid information
+	/* 16th byte */
+	uint8_t SenseKeySpec[3];
+#define  SCSI_SENSE_SKSV            0x80 //!< Indicates the SENSE-KEY SPECIFIC field contains valid information
 };

 COMPILER_PACK_RESET()

 /* Vital Product Data page codes */
 enum scsi_vpd_page_code {
-  SCSI_VPD_SUPPORTED_PAGES = 0x00,
-  SCSI_VPD_UNIT_SERIAL_NUMBER = 0x80,
-  SCSI_VPD_DEVICE_IDENTIFICATION = 0x83,
+	SCSI_VPD_SUPPORTED_PAGES = 0x00,
+	SCSI_VPD_UNIT_SERIAL_NUMBER = 0x80,
+	SCSI_VPD_DEVICE_IDENTIFICATION = 0x83,
 };
 #define  SCSI_VPD_HEADER_SIZE       4

@@ -200,36 +200,37 @@ enum scsi_vpd_page_code {

 #define  SCSI_VPD_ID_TYPE_T10       1

+
 /* Sense keys */
 enum scsi_sense_key {
-  SCSI_SK_NO_SENSE = 0x0,
-  SCSI_SK_RECOVERED_ERROR = 0x1,
-  SCSI_SK_NOT_READY = 0x2,
-  SCSI_SK_MEDIUM_ERROR = 0x3,
-  SCSI_SK_HARDWARE_ERROR = 0x4,
-  SCSI_SK_ILLEGAL_REQUEST = 0x5,
-  SCSI_SK_UNIT_ATTENTION = 0x6,
-  SCSI_SK_DATA_PROTECT = 0x7,
-  SCSI_SK_BLANK_CHECK = 0x8,
-  SCSI_SK_VENDOR_SPECIFIC = 0x9,
-  SCSI_SK_COPY_ABORTED = 0xA,
-  SCSI_SK_ABORTED_COMMAND = 0xB,
-  SCSI_SK_VOLUME_OVERFLOW = 0xD,
-  SCSI_SK_MISCOMPARE = 0xE,
+	SCSI_SK_NO_SENSE = 0x0,
+	SCSI_SK_RECOVERED_ERROR = 0x1,
+	SCSI_SK_NOT_READY = 0x2,
+	SCSI_SK_MEDIUM_ERROR = 0x3,
+	SCSI_SK_HARDWARE_ERROR = 0x4,
+	SCSI_SK_ILLEGAL_REQUEST = 0x5,
+	SCSI_SK_UNIT_ATTENTION = 0x6,
+	SCSI_SK_DATA_PROTECT = 0x7,
+	SCSI_SK_BLANK_CHECK = 0x8,
+	SCSI_SK_VENDOR_SPECIFIC = 0x9,
+	SCSI_SK_COPY_ABORTED = 0xA,
+	SCSI_SK_ABORTED_COMMAND = 0xB,
+	SCSI_SK_VOLUME_OVERFLOW = 0xD,
+	SCSI_SK_MISCOMPARE = 0xE,
 };

 /* Additional Sense Code / Additional Sense Code Qualifier pairs */
 enum scsi_asc_ascq {
-  SCSI_ASC_NO_ADDITIONAL_SENSE_INFO = 0x0000,
-  SCSI_ASC_LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405,
-  SCSI_ASC_WRITE_ERROR = 0x0C00,
-  SCSI_ASC_UNRECOVERED_READ_ERROR = 0x1100,
-  SCSI_ASC_INVALID_COMMAND_OPERATION_CODE = 0x2000,
-  SCSI_ASC_INVALID_FIELD_IN_CDB = 0x2400,
-  SCSI_ASC_WRITE_PROTECTED = 0x2700,
-  SCSI_ASC_NOT_READY_TO_READY_CHANGE = 0x2800,
-  SCSI_ASC_MEDIUM_NOT_PRESENT = 0x3A00,
-  SCSI_ASC_INTERNAL_TARGET_FAILURE = 0x4400,
+	SCSI_ASC_NO_ADDITIONAL_SENSE_INFO = 0x0000,
+	SCSI_ASC_LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405,
+	SCSI_ASC_WRITE_ERROR = 0x0C00,
+	SCSI_ASC_UNRECOVERED_READ_ERROR = 0x1100,
+	SCSI_ASC_INVALID_COMMAND_OPERATION_CODE = 0x2000,
+	SCSI_ASC_INVALID_FIELD_IN_CDB = 0x2400,
+	SCSI_ASC_WRITE_PROTECTED = 0x2700,
+	SCSI_ASC_NOT_READY_TO_READY_CHANGE = 0x2800,
+	SCSI_ASC_MEDIUM_NOT_PRESENT = 0x3A00,
+	SCSI_ASC_INTERNAL_TARGET_FAILURE = 0x4400,
 };

 /**
@@ -239,9 +240,9 @@ enum scsi_asc_ascq {
 * that are applicable to all SCSI devices.
 */
 enum scsi_spc_mode {
-  SCSI_MS_MODE_VENDOR_SPEC = 0x00,
-  SCSI_MS_MODE_INFEXP = 0x1C,    // Informational exceptions control page
-  SCSI_MS_MODE_ALL = 0x3F,
+	SCSI_MS_MODE_VENDOR_SPEC = 0x00,
+	SCSI_MS_MODE_INFEXP = 0x1C,    // Informational exceptions control page
+	SCSI_MS_MODE_ALL = 0x3F,
 };

 /**
@@ -249,45 +250,51 @@ enum scsi_spc_mode {
 * See chapter 8.3.8
 */
 struct spc_control_page_info_execpt {
-  uint8_t page_code;
-  uint8_t page_length;
-  #define SPC_MP_INFEXP_PAGE_LENGTH             0x0A
-  uint8_t flags1;
-  #define SPC_MP_INFEXP_PERF                    (1<<7)   //!< Initiator Control
-  #define SPC_MP_INFEXP_EBF                     (1<<5)   //!< Caching Analysis Permitted
-  #define SPC_MP_INFEXP_EWASC                   (1<<4)   //!< Discontinuity
-  #define SPC_MP_INFEXP_DEXCPT                  (1<<3)   //!< Size enable
-  #define SPC_MP_INFEXP_TEST                    (1<<2)   //!< Writeback Cache Enable
-  #define SPC_MP_INFEXP_LOGERR                  (1<<0)   //!< Log errors bit
-  uint8_t mrie;
-  #define SPC_MP_INFEXP_MRIE_NO_REPORT          0x00
-  #define SPC_MP_INFEXP_MRIE_ASYNC_EVENT        0x01
-  #define SPC_MP_INFEXP_MRIE_GEN_UNIT           0x02
-  #define SPC_MP_INFEXP_MRIE_COND_RECOV_ERROR   0x03
-  #define SPC_MP_INFEXP_MRIE_UNCOND_RECOV_ERROR 0x04
-  #define SPC_MP_INFEXP_MRIE_NO_SENSE           0x05
-  #define SPC_MP_INFEXP_MRIE_ONLY_REPORT        0x06
-  be32_t interval_timer;
-  be32_t report_count;
+	uint8_t page_code;
+	uint8_t page_length;
+#define  SPC_MP_INFEXP_PAGE_LENGTH     0x0A
+	uint8_t flags1;
+#define  SPC_MP_INFEXP_PERF            (1<<7)   //!< Initiator Control
+#define  SPC_MP_INFEXP_EBF             (1<<5)   //!< Caching Analysis Permitted
+#define  SPC_MP_INFEXP_EWASC           (1<<4)   //!< Discontinuity
+#define  SPC_MP_INFEXP_DEXCPT          (1<<3)   //!< Size enable
+#define  SPC_MP_INFEXP_TEST            (1<<2)   //!< Writeback Cache Enable
+#define  SPC_MP_INFEXP_LOGERR          (1<<0)   //!< Log errors bit
+	uint8_t mrie;
+#define  SPC_MP_INFEXP_MRIE_NO_REPORT           0x00
+#define  SPC_MP_INFEXP_MRIE_ASYNC_EVENT         0x01
+#define  SPC_MP_INFEXP_MRIE_GEN_UNIT            0x02
+#define  SPC_MP_INFEXP_MRIE_COND_RECOV_ERROR    0x03
+#define  SPC_MP_INFEXP_MRIE_UNCOND_RECOV_ERROR  0x04
+#define  SPC_MP_INFEXP_MRIE_NO_SENSE            0x05
+#define  SPC_MP_INFEXP_MRIE_ONLY_REPORT         0x06
+	be32_t interval_timer;
+	be32_t report_count;
 };

+
 enum scsi_spc_mode_sense_pc {
-  SCSI_MS_SENSE_PC_CURRENT = 0,
-  SCSI_MS_SENSE_PC_CHANGEABLE = 1,
-  SCSI_MS_SENSE_PC_DEFAULT = 2,
-  SCSI_MS_SENSE_PC_SAVED = 3,
+	SCSI_MS_SENSE_PC_CURRENT = 0,
+	SCSI_MS_SENSE_PC_CHANGEABLE = 1,
+	SCSI_MS_SENSE_PC_DEFAULT = 2,
+	SCSI_MS_SENSE_PC_SAVED = 3,
 };

-static inline bool scsi_mode_sense_dbd_is_set(const uint8_t * cdb) {
-  return (cdb[1] >> 3) & 1;
+
+
+static inline bool scsi_mode_sense_dbd_is_set(const uint8_t * cdb)
+{
+	return (cdb[1] >> 3) & 1;
 }

-static inline uint8_t scsi_mode_sense_get_page_code(const uint8_t * cdb) {
-  return cdb[2] & 0x3F;
+static inline uint8_t scsi_mode_sense_get_page_code(const uint8_t * cdb)
+{
+	return cdb[2] & 0x3F;
 }

-static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb) {
-  return cdb[2] >> 6;
+static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb)
+{
+	return cdb[2] >> 6;
 }

 /**
@@ -295,10 +302,10 @@ static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb) {
 * SENSE(6)
 */
 struct scsi_mode_param_header6 {
-  uint8_t mode_data_length; //!< Number of bytes after this
-  uint8_t medium_type;  //!< Medium Type
-  uint8_t device_specific_parameter;  //!< Defined by command set
-  uint8_t block_descriptor_length;  //!< Length of block descriptors
+	uint8_t mode_data_length;	//!< Number of bytes after this
+	uint8_t medium_type;	//!< Medium Type
+	uint8_t device_specific_parameter;	//!< Defined by command set
+	uint8_t block_descriptor_length;	//!< Length of block descriptors
 };

 /**
@@ -306,23 +313,23 @@ struct scsi_mode_param_header6 {
 * SENSE(10)
 */
 struct scsi_mode_param_header10 {
-  be16_t mode_data_length;  //!< Number of bytes after this
-  uint8_t medium_type;  //!< Medium Type
-  uint8_t device_specific_parameter;  //!< Defined by command set
-  uint8_t flags4; //!< LONGLBA in bit 0
-  uint8_t reserved;
-  be16_t block_descriptor_length; //!< Length of block descriptors
+	be16_t mode_data_length;	//!< Number of bytes after this
+	uint8_t medium_type;	//!< Medium Type
+	uint8_t device_specific_parameter;	//!< Defined by command set
+	uint8_t flags4;	//!< LONGLBA in bit 0
+	uint8_t reserved;
+	be16_t block_descriptor_length;	//!< Length of block descriptors
 };

 /**
 * \brief SCSI Page_0 Mode Page header (SPF not set)
 */
 struct scsi_mode_page_0_header {
-  uint8_t page_code;
-#define SCSI_PAGE_CODE_PS          (1 << 7)  //!< Parameters Saveable
-#define SCSI_PAGE_CODE_SPF         (1 << 6)  //!< SubPage Format
-  uint8_t page_length;  //!< Number of bytes after this
-#define SCSI_MS_PAGE_LEN(total)   ((total) - 2)
+	uint8_t page_code;
+#define  SCSI_PAGE_CODE_PS          (1 << 7)	//!< Parameters Saveable
+#define  SCSI_PAGE_CODE_SPF         (1 << 6)	//!< SubPage Format
+	uint8_t page_length;	//!< Number of bytes after this
+#define  SCSI_MS_PAGE_LEN(total)   ((total) - 2)
 };

 //@}
@@ -71,7 +71,7 @@
 * \subsection sysclk_quickstart_use_case_1_setup_steps Initialization code
 * Add to the application initialization code:
 * \code
-  sysclk_init();
+	sysclk_init();
 \endcode
 *
 * \subsection sysclk_quickstart_use_case_1_setup_steps_workflow Workflow
@@ -82,15 +82,15 @@
 *   Add or uncomment the following in your conf_clock.h header file, commenting out all other
 *   definitions of the same symbol(s):
 *   \code
-     #define CONFIG_SYSCLK_SOURCE        SYSCLK_SRC_PLLACK
+	   #define CONFIG_SYSCLK_SOURCE        SYSCLK_SRC_PLLACK

-     // Fpll0 = (Fclk * PLL_mul) / PLL_div
-     #define CONFIG_PLL0_SOURCE          PLL_SRC_MAINCK_XTAL
-     #define CONFIG_PLL0_MUL             (84000000UL / BOARD_FREQ_MAINCK_XTAL)
-     #define CONFIG_PLL0_DIV             1
+	   // Fpll0 = (Fclk * PLL_mul) / PLL_div
+	   #define CONFIG_PLL0_SOURCE          PLL_SRC_MAINCK_XTAL
+	   #define CONFIG_PLL0_MUL             (84000000UL / BOARD_FREQ_MAINCK_XTAL)
+	   #define CONFIG_PLL0_DIV             1

-     // Fbus = Fsys / BUS_div
-     #define CONFIG_SYSCLK_PRES          SYSCLK_PRES_1
+	   // Fbus = Fsys / BUS_div
+	   #define CONFIG_SYSCLK_PRES          SYSCLK_PRES_1
 \endcode
 *
 * \subsection sysclk_quickstart_use_case_1_example_workflow Workflow
@@ -100,14 +100,14 @@
 *   \code #define CONFIG_PLL0_SOURCE            PLL_SRC_MAINCK_XTAL \endcode
 *  -# Configure the PLL module to multiply the external fast crystal oscillator frequency up to 84MHz:
 *   \code
-  #define CONFIG_PLL0_MUL             (84000000UL / BOARD_FREQ_MAINCK_XTAL)
-  #define CONFIG_PLL0_DIV             1
+	#define CONFIG_PLL0_MUL             (84000000UL / BOARD_FREQ_MAINCK_XTAL)
+	#define CONFIG_PLL0_DIV             1
 \endcode
 *   \note For user boards, \c BOARD_FREQ_MAINCK_XTAL should be defined in the board \c conf_board.h configuration
 *         file as the frequency of the fast crystal attached to the microcontroller.
 *  -# Configure the main clock to run at the full 84MHz, disable scaling of the main system clock speed:
 *    \code
-  #define CONFIG_SYSCLK_PRES         SYSCLK_PRES_1
+	#define CONFIG_SYSCLK_PRES         SYSCLK_PRES_1
 \endcode
 *    \note Some dividers are powers of two, while others are integer division factors. Refer to the
 *          formulas in the conf_clock.h template commented above each division define.
@@ -136,7 +136,7 @@ extern "C" {
 * initialization.
 */
 #ifndef CONFIG_SYSCLK_SOURCE
-  #define CONFIG_SYSCLK_SOURCE   SYSCLK_SRC_MAINCK_4M_RC
+# define CONFIG_SYSCLK_SOURCE   SYSCLK_SRC_MAINCK_4M_RC
 #endif
 /**
 * \def CONFIG_SYSCLK_PRES
@@ -149,7 +149,7 @@ extern "C" {
 * after initialization.
 */
 #ifndef CONFIG_SYSCLK_PRES
-  #define CONFIG_SYSCLK_PRES  0
+# define CONFIG_SYSCLK_PRES  0
 #endif

 //@}
@@ -197,7 +197,7 @@ extern "C" {
 * USB is not required.
 */
 #ifdef __DOXYGEN__
-  #define CONFIG_USBCLK_SOURCE
+# define CONFIG_USBCLK_SOURCE
 #endif

 /**
@@ -209,7 +209,7 @@ extern "C" {
 * defined.
 */
 #ifdef __DOXYGEN__
-  #define CONFIG_USBCLK_DIV
+# define CONFIG_USBCLK_DIV
 #endif


@@ -144,15 +144,15 @@ extern "C" {
 * \code #define USB_DEVICE_ATTACH_AUTO_DISABLE \endcode
 * User C file contains:
 * \code
-  // Authorize VBUS monitoring
-  if (!udc_include_vbus_monitoring()) {
-    // Implement custom VBUS monitoring via GPIO or other
-  }
-  Event_VBUS_present() // VBUS interrupt or GPIO interrupt or other
-  {
-    // Attach USB Device
-    udc_attach();
-  }
+	// Authorize VBUS monitoring
+	if (!udc_include_vbus_monitoring()) {
+	  // Implement custom VBUS monitoring via GPIO or other
+	}
+	Event_VBUS_present() // VBUS interrupt or GPIO interrupt or other
+	{
+	  // Attach USB Device
+	  udc_attach();
+	}
 \endcode
 *
 * - Case of battery charging. conf_usb.h file contains define
@@ -160,20 +160,21 @@ extern "C" {
 * \code #define USB_DEVICE_ATTACH_AUTO_DISABLE \endcode
 * User C file contains:
 * \code
-  Event VBUS present() // VBUS interrupt or GPIO interrupt or ..
-  {
-    // Authorize battery charging, but wait key press to start USB.
-  }
-  Event Key press()
-  {
-    // Stop batteries charging
-    // Start USB
-    udc_attach();
-  }
+	Event VBUS present() // VBUS interrupt or GPIO interrupt or ..
+	{
+	  // Authorize battery charging, but wait key press to start USB.
+	}
+	Event Key press()
+	{
+	  // Stop batteries charging
+	  // Start USB
+	  udc_attach();
+	}
 \endcode
 */
-static inline bool udc_include_vbus_monitoring(void) {
-  return udd_include_vbus_monitoring();
+static inline bool udc_include_vbus_monitoring(void)
+{
+	return udd_include_vbus_monitoring();
 }

 /*! \brief Start the USB Device stack
@@ -191,26 +192,32 @@ void udc_stop(void);
 * then it will attach device when an acceptable Vbus
 * level from the host is detected.
 */
-static inline void udc_attach(void) {
-  udd_attach();
+static inline void udc_attach(void)
+{
+	udd_attach();
 }

+
 /**
 * \brief Detaches the device from the bus
 *
 * The driver must remove pull-up on USB line D- or D+.
 */
-static inline void udc_detach(void) {
-  udd_detach();
+static inline void udc_detach(void)
+{
+	udd_detach();
 }

+
 /*! \brief The USB driver sends a resume signal called \e "Upstream Resume"
 * This is authorized only when the remote wakeup feature is enabled by host.
 */
-static inline void udc_remotewakeup(void) {
-  udd_send_remotewakeup();
+static inline void udc_remotewakeup(void)
+{
+	udd_send_remotewakeup();
 }

+
 /**
 * \brief Returns a pointer on the current interface descriptor
 *
@@ -289,23 +296,23 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 *
 * for AVR and SAM3/4 devices, add to the initialization code:
 * \code
-  sysclk_init();
-  irq_initialize_vectors();
-  cpu_irq_enable();
-  board_init();
-  sleepmgr_init(); // Optional
+	sysclk_init();
+	irq_initialize_vectors();
+	cpu_irq_enable();
+	board_init();
+	sleepmgr_init(); // Optional
 \endcode
 *
 * For SAMD devices, add to the initialization code:
 * \code
-  system_init();
-  irq_initialize_vectors();
-  cpu_irq_enable();
-  sleepmgr_init(); // Optional
+	system_init();
+	irq_initialize_vectors();
+	cpu_irq_enable();
+	sleepmgr_init(); // Optional
 \endcode
 * Add to the main IDLE loop:
 * \code
-  sleepmgr_enter_sleep(); // Optional
+	sleepmgr_enter_sleep(); // Optional
 \endcode
 *
 */
@@ -317,20 +324,20 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 *
 * Content of conf_usb.h:
 * \code
-  #define USB_DEVICE_VENDOR_ID 0x03EB
-  #define USB_DEVICE_PRODUCT_ID 0xXXXX
-  #define USB_DEVICE_MAJOR_VERSION 1
-  #define USB_DEVICE_MINOR_VERSION 0
-  #define USB_DEVICE_POWER 100
-  #define USB_DEVICE_ATTR USB_CONFIG_ATTR_BUS_POWERED
+	#define USB_DEVICE_VENDOR_ID 0x03EB
+	#define USB_DEVICE_PRODUCT_ID 0xXXXX
+	#define USB_DEVICE_MAJOR_VERSION 1
+	#define USB_DEVICE_MINOR_VERSION 0
+	#define USB_DEVICE_POWER 100
+	#define USB_DEVICE_ATTR USB_CONFIG_ATTR_BUS_POWERED
 \endcode
 *
 * Add to application C-file:
 * \code
-  void usb_init(void)
-  {
-    udc_start();
-  }
+	void usb_init(void)
+	{
+	  udc_start();
+	}
 \endcode
 */

@@ -342,17 +349,17 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 * -# Ensure that conf_usb.h is available and contains the following configuration
 * which is the main USB device configuration:
 *   - \code // Vendor ID provided by USB org (ATMEL 0x03EB)
-  #define USB_DEVICE_VENDOR_ID 0x03EB // Type Word
-  // Product ID (Atmel PID referenced in usb_atmel.h)
-  #define USB_DEVICE_PRODUCT_ID 0xXXXX // Type Word
-  // Major version of the device
-  #define USB_DEVICE_MAJOR_VERSION 1 // Type Byte
-  // Minor version of the device
-  #define USB_DEVICE_MINOR_VERSION 0 // Type Byte
-  // Maximum device power (mA)
-  #define USB_DEVICE_POWER 100 // Type 9-bits
-  // USB attributes to enable features
-  #define USB_DEVICE_ATTR USB_CONFIG_ATTR_BUS_POWERED // Flags \endcode
+	#define USB_DEVICE_VENDOR_ID 0x03EB // Type Word
+	// Product ID (Atmel PID referenced in usb_atmel.h)
+	#define USB_DEVICE_PRODUCT_ID 0xXXXX // Type Word
+	// Major version of the device
+	#define USB_DEVICE_MAJOR_VERSION 1 // Type Byte
+	// Minor version of the device
+	#define USB_DEVICE_MINOR_VERSION 0 // Type Byte
+	// Maximum device power (mA)
+	#define USB_DEVICE_POWER 100 // Type 9-bits
+	// USB attributes to enable features
+	#define USB_DEVICE_ATTR USB_CONFIG_ATTR_BUS_POWERED // Flags \endcode
 * -# Call the USB device stack start function to enable stack and start USB:
 *   - \code udc_start(); \endcode
 *     \note In case of USB dual roles (Device and Host) managed through USB OTG connector
@@ -365,90 +372,90 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 *
 * Content of XMEGA conf_clock.h:
 * \code
-  // Configuration based on internal RC:
-  // USB clock need of 48Mhz
-  #define CONFIG_USBCLK_SOURCE        USBCLK_SRC_RCOSC
-  #define CONFIG_OSC_RC32_CAL         48000000UL
-  #define CONFIG_OSC_AUTOCAL_RC32MHZ_REF_OSC  OSC_ID_USBSOF
-  // CPU clock need of clock > 12MHz to run with USB (Here 24MHz)
-  #define CONFIG_SYSCLK_SOURCE     SYSCLK_SRC_RC32MHZ
-  #define CONFIG_SYSCLK_PSADIV     SYSCLK_PSADIV_2
-  #define CONFIG_SYSCLK_PSBCDIV    SYSCLK_PSBCDIV_1_1
+	// Configuration based on internal RC:
+	// USB clock need of 48Mhz
+	#define CONFIG_USBCLK_SOURCE        USBCLK_SRC_RCOSC
+	#define CONFIG_OSC_RC32_CAL         48000000UL
+	#define CONFIG_OSC_AUTOCAL_RC32MHZ_REF_OSC  OSC_ID_USBSOF
+	// CPU clock need of clock > 12MHz to run with USB (Here 24MHz)
+	#define CONFIG_SYSCLK_SOURCE     SYSCLK_SRC_RC32MHZ
+	#define CONFIG_SYSCLK_PSADIV     SYSCLK_PSADIV_2
+	#define CONFIG_SYSCLK_PSBCDIV    SYSCLK_PSBCDIV_1_1
 \endcode
 *
 * Content of conf_clock.h for AT32UC3A0, AT32UC3A1, AT32UC3B devices (USBB):
 * \code
-  // Configuration based on 12MHz external OSC:
-  #define CONFIG_PLL1_SOURCE          PLL_SRC_OSC0
-  #define CONFIG_PLL1_MUL             8
-  #define CONFIG_PLL1_DIV             2
-  #define CONFIG_USBCLK_SOURCE        USBCLK_SRC_PLL1
-  #define CONFIG_USBCLK_DIV           1 // Fusb = Fsys/(2 ^ USB_div)
+	// Configuration based on 12MHz external OSC:
+	#define CONFIG_PLL1_SOURCE          PLL_SRC_OSC0
+	#define CONFIG_PLL1_MUL             8
+	#define CONFIG_PLL1_DIV             2
+	#define CONFIG_USBCLK_SOURCE        USBCLK_SRC_PLL1
+	#define CONFIG_USBCLK_DIV           1 // Fusb = Fsys/(2 ^ USB_div)
 \endcode
 *
 * Content of conf_clock.h for AT32UC3A3, AT32UC3A4 devices (USBB with high speed support):
 * \code
-  // Configuration based on 12MHz external OSC:
-  #define CONFIG_USBCLK_SOURCE        USBCLK_SRC_OSC0
-  #define CONFIG_USBCLK_DIV           1 // Fusb = Fsys/(2 ^ USB_div)
+	// Configuration based on 12MHz external OSC:
+	#define CONFIG_USBCLK_SOURCE        USBCLK_SRC_OSC0
+	#define CONFIG_USBCLK_DIV           1 // Fusb = Fsys/(2 ^ USB_div)
 \endcode
 *
 * Content of conf_clock.h for AT32UC3C, ATUCXXD, ATUCXXL3U, ATUCXXL4U devices (USBC):
 * \code
-  // Configuration based on 12MHz external OSC:
-  #define CONFIG_PLL1_SOURCE          PLL_SRC_OSC0
-  #define CONFIG_PLL1_MUL             8
-  #define CONFIG_PLL1_DIV             2
-  #define CONFIG_USBCLK_SOURCE        USBCLK_SRC_PLL1
-  #define CONFIG_USBCLK_DIV           1 // Fusb = Fsys/(2 ^ USB_div)
-  // CPU clock need of clock > 25MHz to run with USBC
-  #define CONFIG_SYSCLK_SOURCE        SYSCLK_SRC_PLL1
+	// Configuration based on 12MHz external OSC:
+	#define CONFIG_PLL1_SOURCE          PLL_SRC_OSC0
+	#define CONFIG_PLL1_MUL             8
+	#define CONFIG_PLL1_DIV             2
+	#define CONFIG_USBCLK_SOURCE        USBCLK_SRC_PLL1
+	#define CONFIG_USBCLK_DIV           1 // Fusb = Fsys/(2 ^ USB_div)
+	// CPU clock need of clock > 25MHz to run with USBC
+	#define CONFIG_SYSCLK_SOURCE        SYSCLK_SRC_PLL1
 \endcode
 *
 * Content of conf_clock.h for SAM3S, SAM3SD, SAM4S devices (UPD: USB Peripheral Device):
 * \code
-  // PLL1 (B) Options   (Fpll = (Fclk * PLL_mul) / PLL_div)
-  #define CONFIG_PLL1_SOURCE          PLL_SRC_MAINCK_XTAL
-  #define CONFIG_PLL1_MUL             16
-  #define CONFIG_PLL1_DIV             2
-  // USB Clock Source Options   (Fusb = FpllX / USB_div)
-  #define CONFIG_USBCLK_SOURCE        USBCLK_SRC_PLL1
-  #define CONFIG_USBCLK_DIV           2
+	// PLL1 (B) Options   (Fpll = (Fclk * PLL_mul) / PLL_div)
+	#define CONFIG_PLL1_SOURCE          PLL_SRC_MAINCK_XTAL
+	#define CONFIG_PLL1_MUL             16
+	#define CONFIG_PLL1_DIV             2
+	// USB Clock Source Options   (Fusb = FpllX / USB_div)
+	#define CONFIG_USBCLK_SOURCE        USBCLK_SRC_PLL1
+	#define CONFIG_USBCLK_DIV           2
 \endcode
 *
 * Content of conf_clock.h for SAM3U device (UPDHS: USB Peripheral Device High Speed):
 * \code
-  // USB Clock Source fixed at UPLL.
+	// USB Clock Source fixed at UPLL.
 \endcode
 *
 * Content of conf_clock.h for SAM3X, SAM3A devices (UOTGHS: USB OTG High Speed):
 * \code
-  // USB Clock Source fixed at UPLL.
-  #define CONFIG_USBCLK_SOURCE        USBCLK_SRC_UPLL
-  #define CONFIG_USBCLK_DIV           1
+	// USB Clock Source fixed at UPLL.
+	#define CONFIG_USBCLK_SOURCE        USBCLK_SRC_UPLL
+	#define CONFIG_USBCLK_DIV           1
 \endcode
 *
 * Content of conf_clocks.h for SAMD devices (USB):
 * \code
-  // System clock bus configuration
-  #  define CONF_CLOCK_FLASH_WAIT_STATES            2
+	// System clock bus configuration
+	#  define CONF_CLOCK_FLASH_WAIT_STATES            2

-  // USB Clock Source fixed at DFLL.
-  // SYSTEM_CLOCK_SOURCE_DFLL configuration - Digital Frequency Locked Loop
-  #  define CONF_CLOCK_DFLL_ENABLE                  true
-  #  define CONF_CLOCK_DFLL_LOOP_MODE               SYSTEM_CLOCK_DFLL_LOOP_MODE_USB_RECOVERY
-  #  define CONF_CLOCK_DFLL_ON_DEMAND               true
+	// USB Clock Source fixed at DFLL.
+	// SYSTEM_CLOCK_SOURCE_DFLL configuration - Digital Frequency Locked Loop
+	#  define CONF_CLOCK_DFLL_ENABLE                  true
+	#  define CONF_CLOCK_DFLL_LOOP_MODE               SYSTEM_CLOCK_DFLL_LOOP_MODE_USB_RECOVERY
+	#  define CONF_CLOCK_DFLL_ON_DEMAND               true

-  // Set this to true to configure the GCLK when running clocks_init.
-  // If set to false, none of the GCLK generators will be configured in clocks_init().
-  #  define CONF_CLOCK_CONFIGURE_GCLK               true
+	// Set this to true to configure the GCLK when running clocks_init.
+	// If set to false, none of the GCLK generators will be configured in clocks_init().
+	#  define CONF_CLOCK_CONFIGURE_GCLK               true

-  // Configure GCLK generator 0 (Main Clock)
-  #  define CONF_CLOCK_GCLK_0_ENABLE                true
-  #  define CONF_CLOCK_GCLK_0_RUN_IN_STANDBY        true
-  #  define CONF_CLOCK_GCLK_0_CLOCK_SOURCE          SYSTEM_CLOCK_SOURCE_DFLL
-  #  define CONF_CLOCK_GCLK_0_PRESCALER             1
-  #  define CONF_CLOCK_GCLK_0_OUTPUT_ENABLE         false
+	// Configure GCLK generator 0 (Main Clock)
+	#  define CONF_CLOCK_GCLK_0_ENABLE                true
+	#  define CONF_CLOCK_GCLK_0_RUN_IN_STANDBY        true
+	#  define CONF_CLOCK_GCLK_0_CLOCK_SOURCE          SYSTEM_CLOCK_SOURCE_DFLL
+	#  define CONF_CLOCK_GCLK_0_PRESCALER             1
+	#  define CONF_CLOCK_GCLK_0_OUTPUT_ENABLE         false
 \endcode
 */

@@ -467,34 +474,34 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 * \subsection udc_use_case_1_usage_code Example code
 * Content of conf_usb.h:
 * \code
-   #if // Low speed
-   #define USB_DEVICE_LOW_SPEED
-   // #define USB_DEVICE_HS_SUPPORT
+	 #if // Low speed
+	 #define USB_DEVICE_LOW_SPEED
+	 // #define USB_DEVICE_HS_SUPPORT

-   #elif // Full speed
-   // #define USB_DEVICE_LOW_SPEED
-   // #define USB_DEVICE_HS_SUPPORT
+	 #elif // Full speed
+	 // #define USB_DEVICE_LOW_SPEED
+	 // #define USB_DEVICE_HS_SUPPORT

-   #elif // High speed
-   // #define USB_DEVICE_LOW_SPEED
-   #define USB_DEVICE_HS_SUPPORT
+	 #elif // High speed
+	 // #define USB_DEVICE_LOW_SPEED
+	 #define USB_DEVICE_HS_SUPPORT

-   #endif
+	 #endif
 \endcode
 *
 * \subsection udc_use_case_1_usage_flow Workflow
 * -# Ensure that conf_usb.h is available and contains the following parameters
 * required for a USB device low speed (1.5Mbit/s):
 *   - \code #define USB_DEVICE_LOW_SPEED
-   //#define  USB_DEVICE_HS_SUPPORT \endcode
+	 //#define  USB_DEVICE_HS_SUPPORT \endcode
 * -# Ensure that conf_usb.h contains the following parameters
 * required for a USB device full speed (12Mbit/s):
 *   - \code //#define USB_DEVICE_LOW_SPEED
-   //#define  USB_DEVICE_HS_SUPPORT \endcode
+	 //#define  USB_DEVICE_HS_SUPPORT \endcode
 * -# Ensure that conf_usb.h contains the following parameters
 * required for a USB device high speed (480Mbit/s):
 *   - \code //#define USB_DEVICE_LOW_SPEED
-   #define  USB_DEVICE_HS_SUPPORT \endcode
+	 #define  USB_DEVICE_HS_SUPPORT \endcode
 */

 /**
@@ -511,20 +518,20 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 * \subsection udc_use_case_2_usage_code Example code
 * Content of conf_usb.h:
 * \code
-  #define  USB_DEVICE_MANUFACTURE_NAME      "Manufacture name"
-  #define  USB_DEVICE_PRODUCT_NAME          "Product name"
-  #define  USB_DEVICE_SERIAL_NAME           "12...EF"
+	#define  USB_DEVICE_MANUFACTURE_NAME      "Manufacture name"
+	#define  USB_DEVICE_PRODUCT_NAME          "Product name"
+	#define  USB_DEVICE_SERIAL_NAME           "12...EF"
 \endcode
 *
 * \subsection udc_use_case_2_usage_flow Workflow
 * -# Ensure that conf_usb.h is available and contains the following parameters
 * required to enable different USB strings:
 *   - \code // Static ASCII name for the manufacture
-  #define  USB_DEVICE_MANUFACTURE_NAME "Manufacture name" \endcode
+	#define  USB_DEVICE_MANUFACTURE_NAME "Manufacture name" \endcode
 *   - \code // Static ASCII name for the product
-  #define  USB_DEVICE_PRODUCT_NAME "Product name" \endcode
+	#define  USB_DEVICE_PRODUCT_NAME "Product name" \endcode
 *   - \code // Static ASCII name to enable and set a serial number
-  #define  USB_DEVICE_SERIAL_NAME "12...EF" \endcode
+	#define  USB_DEVICE_SERIAL_NAME "12...EF" \endcode
 */

 /**
@@ -541,42 +548,42 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 * \subsection udc_use_case_3_usage_code Example code
 * Content of conf_usb.h:
 * \code
-  #define  USB_DEVICE_ATTR \
-    (USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_..._POWERED)
-  #define UDC_REMOTEWAKEUP_ENABLE() my_callback_remotewakeup_enable()
-  extern void my_callback_remotewakeup_enable(void);
-  #define UDC_REMOTEWAKEUP_DISABLE() my_callback_remotewakeup_disable()
-  extern void my_callback_remotewakeup_disable(void);
+	#define  USB_DEVICE_ATTR \
+	  (USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_..._POWERED)
+	#define UDC_REMOTEWAKEUP_ENABLE() my_callback_remotewakeup_enable()
+	extern void my_callback_remotewakeup_enable(void);
+	#define UDC_REMOTEWAKEUP_DISABLE() my_callback_remotewakeup_disable()
+	extern void my_callback_remotewakeup_disable(void);
 \endcode
 *
 * Add to application C-file:
 * \code
-   void my_callback_remotewakeup_enable(void)
-   {
-      // Enable application wakeup events (e.g. enable GPIO interrupt)
-   }
-   void my_callback_remotewakeup_disable(void)
-   {
-      // Disable application wakeup events (e.g. disable GPIO interrupt)
-   }
+	 void my_callback_remotewakeup_enable(void)
+	 {
+	    // Enable application wakeup events (e.g. enable GPIO interrupt)
+	 }
+	 void my_callback_remotewakeup_disable(void)
+	 {
+	    // Disable application wakeup events (e.g. disable GPIO interrupt)
+	 }

-   void my_interrupt_event(void)
-   {
-      udc_remotewakeup();
-   }
+	 void my_interrupt_event(void)
+	 {
+	    udc_remotewakeup();
+	 }
 \endcode
 *
 * \subsection udc_use_case_3_usage_flow Workflow
 * -# Ensure that conf_usb.h is available and contains the following parameters
 * required to enable remote wakeup feature:
 *   - \code // Authorizes the remote wakeup feature
-       #define  USB_DEVICE_ATTR (USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_..._POWERED) \endcode
+	     #define  USB_DEVICE_ATTR (USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_..._POWERED) \endcode
 *   - \code // Define callback called when the host enables the remotewakeup feature
-  #define UDC_REMOTEWAKEUP_ENABLE() my_callback_remotewakeup_enable()
-  extern void my_callback_remotewakeup_enable(void); \endcode
+	#define UDC_REMOTEWAKEUP_ENABLE() my_callback_remotewakeup_enable()
+	extern void my_callback_remotewakeup_enable(void); \endcode
 *   - \code // Define callback called when the host disables the remotewakeup feature
-  #define UDC_REMOTEWAKEUP_DISABLE() my_callback_remotewakeup_disable()
-  extern void my_callback_remotewakeup_disable(void); \endcode
+	#define UDC_REMOTEWAKEUP_DISABLE() my_callback_remotewakeup_disable()
+	extern void my_callback_remotewakeup_disable(void); \endcode
 * -# Send a remote wakeup (USB upstream):
 *   - \code udc_remotewakeup(); \endcode
 */
@@ -596,40 +603,40 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 * \subsection udc_use_case_5_usage_code Example code
 * Content of conf_usb.h:
 * \code
-  #define  USB_DEVICE_ATTR (USB_CONFIG_ATTR_BUS_POWERED)
-  #define  UDC_SUSPEND_EVENT()         user_callback_suspend_action()
-  extern void user_callback_suspend_action(void)
-  #define  UDC_RESUME_EVENT()          user_callback_resume_action()
-  extern void user_callback_resume_action(void)
+	#define  USB_DEVICE_ATTR (USB_CONFIG_ATTR_BUS_POWERED)
+	#define  UDC_SUSPEND_EVENT()         user_callback_suspend_action()
+	extern void user_callback_suspend_action(void)
+	#define  UDC_RESUME_EVENT()          user_callback_resume_action()
+	extern void user_callback_resume_action(void)
 \endcode
 *
 * Add to application C-file:
 * \code
-  void user_callback_suspend_action(void)
-  {
-     // Disable hardware component to reduce power consumption
-  }
-  void user_callback_resume_action(void)
-  {
-     // Re-enable hardware component
-  }
+	void user_callback_suspend_action(void)
+	{
+	   // Disable hardware component to reduce power consumption
+	}
+	void user_callback_resume_action(void)
+	{
+	   // Re-enable hardware component
+	}
 \endcode
 *
 * \subsection udc_use_case_5_usage_flow Workflow
 * -# Ensure that conf_usb.h is available and contains the following parameters:
 *   - \code // Authorizes the BUS power feature
-  #define  USB_DEVICE_ATTR (USB_CONFIG_ATTR_BUS_POWERED) \endcode
+	#define  USB_DEVICE_ATTR (USB_CONFIG_ATTR_BUS_POWERED) \endcode
 *   - \code // Define callback called when the host suspend the USB line
-  #define UDC_SUSPEND_EVENT() user_callback_suspend_action()
-  extern void user_callback_suspend_action(void); \endcode
+	#define UDC_SUSPEND_EVENT() user_callback_suspend_action()
+	extern void user_callback_suspend_action(void); \endcode
 *   - \code // Define callback called when the host or device resume the USB line
-  #define UDC_RESUME_EVENT() user_callback_resume_action()
-  extern void user_callback_resume_action(void); \endcode
+	#define UDC_RESUME_EVENT() user_callback_resume_action()
+	extern void user_callback_resume_action(void); \endcode
 * -# Reduce power consumption in suspend mode (max. 2.5mA on Vbus):
 *   - \code void user_callback_suspend_action(void)
-  {
-  turn_off_components();
-  } \endcode
+	{
+	turn_off_components();
+	} \endcode
 */

 /**
@@ -647,42 +654,42 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 * \subsection udc_use_case_6_usage_code Example code
 * Content of conf_usb.h:
 * \code
-  #define  USB_DEVICE_SERIAL_NAME
-  #define  USB_DEVICE_GET_SERIAL_NAME_POINTER serial_number
-  #define  USB_DEVICE_GET_SERIAL_NAME_LENGTH  12
-  extern uint8_t serial_number[];
+	#define  USB_DEVICE_SERIAL_NAME
+	#define  USB_DEVICE_GET_SERIAL_NAME_POINTER serial_number
+	#define  USB_DEVICE_GET_SERIAL_NAME_LENGTH  12
+	extern uint8_t serial_number[];
 \endcode
 *
 * Add to application C-file:
 * \code
-   uint8_t serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH];
+	 uint8_t serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH];

-   void init_build_usb_serial_number(void)
-   {
-   serial_number[0] = 'A';
-   serial_number[1] = 'B';
-   ...
-   serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH-1] = 'C';
-   } \endcode
+	 void init_build_usb_serial_number(void)
+	 {
+	 serial_number[0] = 'A';
+	 serial_number[1] = 'B';
+	 ...
+	 serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH-1] = 'C';
+	 } \endcode
 *
 * \subsection udc_use_case_6_usage_flow Workflow
 * -# Ensure that conf_usb.h is available and contains the following parameters
 * required to enable a USB serial number strings dynamically:
 *   - \code #define  USB_DEVICE_SERIAL_NAME // Define this empty
-  #define  USB_DEVICE_GET_SERIAL_NAME_POINTER serial_number // Give serial array pointer
-  #define  USB_DEVICE_GET_SERIAL_NAME_LENGTH  12 // Give size of serial array
-  extern uint8_t serial_number[]; // Declare external serial array \endcode
+	#define  USB_DEVICE_GET_SERIAL_NAME_POINTER serial_number // Give serial array pointer
+	#define  USB_DEVICE_GET_SERIAL_NAME_LENGTH  12 // Give size of serial array
+	extern uint8_t serial_number[]; // Declare external serial array \endcode
 * -# Before start USB stack, initialize the serial array
 *   - \code
-   uint8_t serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH];
+	 uint8_t serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH];

-   void init_build_usb_serial_number(void)
-   {
-   serial_number[0] = 'A';
-   serial_number[1] = 'B';
-   ...
-   serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH-1] = 'C';
-   } \endcode
+	 void init_build_usb_serial_number(void)
+	 {
+	 serial_number[0] = 'A';
+	 serial_number[1] = 'B';
+	 ...
+	 serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH-1] = 'C';
+	 } \endcode
 */


@@ -78,47 +78,50 @@ extern "C" {
 * For Mega application used "code".
 */
 #define  UDC_DESC_STORAGE
-  // Descriptor storage in internal RAM
+	// Descriptor storage in internal RAM
 #if (defined UDC_DATA_USE_HRAM_SUPPORT)
-  #if defined(__GNUC__)
-  #define UDC_DATA(x)   COMPILER_WORD_ALIGNED __attribute__((__section__(".data_hram0")))
-  #define UDC_BSS(x)    COMPILER_ALIGNED(x)   __attribute__((__section__(".bss_hram0")))
-#elif defined(__ICCAVR32__)
-  #define UDC_DATA(x)   COMPILER_ALIGNED(x)   __data32
-  #define UDC_BSS(x)    COMPILER_ALIGNED(x)   __data32
-#endif
+#	if defined(__GNUC__)
+#		define UDC_DATA(x)              COMPILER_WORD_ALIGNED __attribute__((__section__(".data_hram0")))
+#		define UDC_BSS(x)               COMPILER_ALIGNED(x)   __attribute__((__section__(".bss_hram0")))
+#	elif defined(__ICCAVR32__)
+#		define UDC_DATA(x)              COMPILER_ALIGNED(x)   __data32
+#		define UDC_BSS(x)               COMPILER_ALIGNED(x)   __data32
+#	endif
 #else
-  #define UDC_DATA(x)   COMPILER_ALIGNED(x)
-  #define UDC_BSS(x)    COMPILER_ALIGNED(x)
+#	define UDC_DATA(x)              COMPILER_ALIGNED(x)
+#	define UDC_BSS(x)               COMPILER_ALIGNED(x)
 #endif

+
+
 /**
 * \brief Configuration descriptor and UDI link for one USB speed
 */
 typedef struct {
-  //! USB configuration descriptor
-  usb_conf_desc_t UDC_DESC_STORAGE *desc;
-  //! Array of UDI API pointer
-  udi_api_t UDC_DESC_STORAGE *UDC_DESC_STORAGE * udi_apis;
+	//! USB configuration descriptor
+	usb_conf_desc_t UDC_DESC_STORAGE *desc;
+	//! Array of UDI API pointer
+	udi_api_t UDC_DESC_STORAGE *UDC_DESC_STORAGE * udi_apis;
 } udc_config_speed_t;

+
 /**
 * \brief All information about the USB Device
 */
 typedef struct {
-  //! USB device descriptor for low or full speed
-  usb_dev_desc_t UDC_DESC_STORAGE *confdev_lsfs;
-  //! USB configuration descriptor and UDI API pointers for low or full speed
-  udc_config_speed_t UDC_DESC_STORAGE *conf_lsfs;
-  #ifdef USB_DEVICE_HS_SUPPORT
-    //! USB device descriptor for high speed
-    usb_dev_desc_t UDC_DESC_STORAGE *confdev_hs;
-    //! USB device qualifier, only use in high speed mode
-    usb_dev_qual_desc_t UDC_DESC_STORAGE *qualifier;
-    //! USB configuration descriptor and UDI API pointers for high speed
-    udc_config_speed_t UDC_DESC_STORAGE *conf_hs;
-  #endif
-  usb_dev_bos_desc_t UDC_DESC_STORAGE *conf_bos;
+	//! USB device descriptor for low or full speed
+	usb_dev_desc_t UDC_DESC_STORAGE *confdev_lsfs;
+	//! USB configuration descriptor and UDI API pointers for low or full speed
+	udc_config_speed_t UDC_DESC_STORAGE *conf_lsfs;
+#ifdef USB_DEVICE_HS_SUPPORT
+	//! USB device descriptor for high speed
+	usb_dev_desc_t UDC_DESC_STORAGE *confdev_hs;
+	//! USB device qualifier, only use in high speed mode
+	usb_dev_qual_desc_t UDC_DESC_STORAGE *qualifier;
+	//! USB configuration descriptor and UDI API pointers for high speed
+	udc_config_speed_t UDC_DESC_STORAGE *conf_hs;
+#endif
+	usb_dev_bos_desc_t UDC_DESC_STORAGE *conf_bos;
 } udc_config_t;

 //! Global variables of USB Device Descriptor and UDI links
@@ -71,8 +71,8 @@ typedef uint8_t udd_ep_id_t;
 //! \brief Endpoint transfer status
 //! Returned in parameters of callback register via udd_ep_run routine.
 typedef enum {
-  UDD_EP_TRANSFER_OK = 0,
-  UDD_EP_TRANSFER_ABORT = 1,
+	UDD_EP_TRANSFER_OK = 0,
+	UDD_EP_TRANSFER_ABORT = 1,
 } udd_ep_status_t;

 /**
@@ -82,37 +82,41 @@ typedef enum {
 * It can be updated by udc_process_setup() from UDC or *setup() from UDIs.
 */
 typedef struct {
-  //! Data received in USB SETUP packet
-  //! Note: The swap of "req.wValues" from uin16_t to le16_t is done by UDD.
-  usb_setup_req_t req;
+	//! Data received in USB SETUP packet
+	//! Note: The swap of "req.wValues" from uin16_t to le16_t is done by UDD.
+	usb_setup_req_t req;

-  //! Point to buffer to send or fill with data following SETUP packet
-  //! This buffer must be word align for DATA IN phase (use prefix COMPILER_WORD_ALIGNED for buffer)
-  uint8_t *payload;
+	//! Point to buffer to send or fill with data following SETUP packet
+	//! This buffer must be word align for DATA IN phase (use prefix COMPILER_WORD_ALIGNED for buffer)
+	uint8_t *payload;

-  //! Size of buffer to send or fill, and content the number of byte transferred
-  uint16_t payload_size;
+	//! Size of buffer to send or fill, and content the number of byte transferred
+	uint16_t payload_size;

-  //! Callback called after reception of ZLP from setup request
-  void (*callback)(void);
+	//! Callback called after reception of ZLP from setup request
+	void (*callback)(void);

-  //! Callback called when the buffer given (.payload) is full or empty.
-  //! This one return false to abort data transfer, or true with a new buffer in .payload.
-  bool (*over_under_run)(void);
+	//! Callback called when the buffer given (.payload) is full or empty.
+	//! This one return false to abort data transfer, or true with a new buffer in .payload.
+	bool (*over_under_run)(void);
 } udd_ctrl_request_t;
 extern udd_ctrl_request_t udd_g_ctrlreq;

 //! Return true if the setup request \a udd_g_ctrlreq indicates IN data transfer
-#define  Udd_setup_is_in()     (USB_REQ_DIR_IN == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
+#define  Udd_setup_is_in()       \
+      (USB_REQ_DIR_IN == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))

 //! Return true if the setup request \a udd_g_ctrlreq indicates OUT data transfer
-#define  Udd_setup_is_out()    (USB_REQ_DIR_OUT == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
+#define  Udd_setup_is_out()      \
+      (USB_REQ_DIR_OUT == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))

 //! Return the type of the SETUP request \a udd_g_ctrlreq. \see usb_reqtype.
-#define  Udd_setup_type()      (udd_g_ctrlreq.req.bmRequestType & USB_REQ_TYPE_MASK)
+#define  Udd_setup_type()        \
+      (udd_g_ctrlreq.req.bmRequestType & USB_REQ_TYPE_MASK)

 //! Return the recipient of the SETUP request \a udd_g_ctrlreq. \see usb_recipient
-#define  Udd_setup_recipient() (udd_g_ctrlreq.req.bmRequestType & USB_REQ_RECIP_MASK)
+#define  Udd_setup_recipient()   \
+      (udd_g_ctrlreq.req.bmRequestType & USB_REQ_RECIP_MASK)

 /**
 * \brief End of halt callback function type.
@@ -130,7 +134,8 @@ typedef void (*udd_callback_halt_cleared_t)(void);
 * \param status     UDD_EP_TRANSFER_ABORT, if transfer is aborted
 * \param n          number of data transferred
 */
-typedef void (*udd_callback_trans_t) (udd_ep_status_t status, iram_size_t nb_transferred, udd_ep_id_t ep);
+typedef void (*udd_callback_trans_t) (udd_ep_status_t status,
+		iram_size_t nb_transferred, udd_ep_id_t ep);

 /**
 * \brief Authorizes the VBUS event
@@ -234,7 +239,8 @@ void udd_set_setup_payload( uint8_t *payload, uint16_t payload_size );
 *
 * \return \c 1 if the endpoint is enabled, otherwise \c 0.
 */
-bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes, uint16_t MaxEndpointSize);
+bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes,
+		uint16_t MaxEndpointSize);

 /**
 * \brief Disables an endpoint
@@ -288,7 +294,8 @@ bool udd_ep_clear_halt(udd_ep_id_t ep);
 *
 * \return \c 1 if the register is accepted, otherwise \c 0.
 */
-bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callback);
+bool udd_ep_wait_stall_clear(udd_ep_id_t ep,
+		udd_callback_halt_cleared_t callback);

 /**
 * \brief Allows to receive or send data on an endpoint
@@ -314,8 +321,9 @@ bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callbac
 *
 * \return \c 1 if function was successfully done, otherwise \c 0.
 */
-bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t * buf, iram_size_t buf_size, udd_callback_trans_t callback);
-
+bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket,
+		uint8_t * buf, iram_size_t buf_size,
+		udd_callback_trans_t callback);
 /**
 * \brief Aborts transfer on going on endpoint
 *
@@ -331,6 +339,7 @@ void udd_ep_abort(udd_ep_id_t ep);

 //@}

+
 /**
 * \name High speed test mode management
 *
@@ -343,6 +352,7 @@ void udd_test_mode_se0_nak(void);
 void udd_test_mode_packet(void);
 //@}

+
 /**
 * \name UDC callbacks to provide for UDD
 *
@@ -72,57 +72,57 @@ extern "C" {
 * selected by UDC.
 */
 typedef struct {
-  /**
-   * \brief Enable the interface.
-   *
-   * This function is called when the host selects a configuration
-   * to which this interface belongs through a Set Configuration
-   * request, and when the host selects an alternate setting of
-   * this interface through a Set Interface request.
-   *
-   * \return \c 1 if function was successfully done, otherwise \c 0.
-   */
-  bool (*enable)(void);
+	/**
+	 * \brief Enable the interface.
+	 *
+	 * This function is called when the host selects a configuration
+	 * to which this interface belongs through a Set Configuration
+	 * request, and when the host selects an alternate setting of
+	 * this interface through a Set Interface request.
+	 *
+	 * \return \c 1 if function was successfully done, otherwise \c 0.
+	 */
+	bool (*enable)(void);

-  /**
-   * \brief Disable the interface.
-   *
-   * This function is called when this interface is currently
-   * active, and
-   * - the host selects any configuration through a Set
-   *   Configuration request, or
-   * - the host issues a USB reset, or
-   * - the device is detached from the host (i.e. Vbus is no
-   *   longer present)
-   */
-  void (*disable)(void);
+	/**
+	 * \brief Disable the interface.
+	 *
+	 * This function is called when this interface is currently
+	 * active, and
+	 * - the host selects any configuration through a Set
+	 *   Configuration request, or
+	 * - the host issues a USB reset, or
+	 * - the device is detached from the host (i.e. Vbus is no
+	 *   longer present)
+	 */
+	void (*disable)(void);

-  /**
-   * \brief Handle a control request directed at an interface.
-   *
-   * This function is called when this interface is currently
-   * active and the host sends a SETUP request
-   * with this interface as the recipient.
-   *
-   * Use udd_g_ctrlreq to decode and response to SETUP request.
-   *
-   * \return \c 1 if this interface supports the SETUP request, otherwise \c 0.
-   */
-  bool (*setup)(void);
+	/**
+	 * \brief Handle a control request directed at an interface.
+	 *
+	 * This function is called when this interface is currently
+	 * active and the host sends a SETUP request
+	 * with this interface as the recipient.
+	 *
+	 * Use udd_g_ctrlreq to decode and response to SETUP request.
+	 *
+	 * \return \c 1 if this interface supports the SETUP request, otherwise \c 0.
+	 */
+	bool (*setup)(void);

-  /**
-   * \brief Returns the current setting of the selected interface.
-   *
-   * This function is called when UDC when know alternate setting of selected interface.
-   *
-   * \return alternate setting of selected interface
-   */
-  uint8_t (*getsetting)(void);
+	/**
+	 * \brief Returns the current setting of the selected interface.
+	 *
+	 * This function is called when UDC when know alternate setting of selected interface.
+	 *
+	 * \return alternate setting of selected interface
+	 */
+	uint8_t (*getsetting)(void);

-  /**
-   * \brief To signal that a SOF is occurred
-   */
-  void (*sof_notify)(void);
+	/**
+	 * \brief To signal that a SOF is occurred
+	 */
+	void (*sof_notify)(void);
 } udi_api_t;

 //@}
@@ -92,18 +92,18 @@ extern UDC_DESC_STORAGE udi_api_t udi_api_cdc_data;
 * descriptors for the CDC Communication Class interface.
 */
 typedef struct {
-  //! Standard interface descriptor
-  usb_iface_desc_t iface;
-  //! CDC Header functional descriptor
-  usb_cdc_hdr_desc_t header;
-  //! CDC Abstract Control Model functional descriptor
-  usb_cdc_acm_desc_t acm;
-  //! CDC Union functional descriptor
-  usb_cdc_union_desc_t union_desc;
-  //! CDC Call Management functional descriptor
-  usb_cdc_call_mgmt_desc_t call_mgmt;
-  //! Notification endpoint descriptor
-  usb_ep_desc_t ep_notify;
+	//! Standard interface descriptor
+	usb_iface_desc_t iface;
+	//! CDC Header functional descriptor
+	usb_cdc_hdr_desc_t header;
+	//! CDC Abstract Control Model functional descriptor
+	usb_cdc_acm_desc_t acm;
+	//! CDC Union functional descriptor
+	usb_cdc_union_desc_t union_desc;
+	//! CDC Call Management functional descriptor
+	usb_cdc_call_mgmt_desc_t call_mgmt;
+	//! Notification endpoint descriptor
+	usb_ep_desc_t ep_notify;
 } udi_cdc_comm_desc_t;


@@ -114,11 +114,11 @@ typedef struct {
 * CDC Data Class interface.
 */
 typedef struct {
-  //! Standard interface descriptor
-  usb_iface_desc_t iface;
-  //! Data IN/OUT endpoint descriptors
-  usb_ep_desc_t ep_in;
-  usb_ep_desc_t ep_out;
+	//! Standard interface descriptor
+	usb_iface_desc_t iface;
+	//! Data IN/OUT endpoint descriptors
+	usb_ep_desc_t ep_in;
+	usb_ep_desc_t ep_out;
 } udi_cdc_data_desc_t;


@@ -136,13 +136,13 @@ typedef struct {
 //@{
 //! By default no string associated to these interfaces
 #ifndef UDI_CDC_IAD_STRING_ID_0
-  #define UDI_CDC_IAD_STRING_ID_0   0
+#define UDI_CDC_IAD_STRING_ID_0   0
 #endif
 #ifndef UDI_CDC_COMM_STRING_ID_0
-  #define UDI_CDC_COMM_STRING_ID_0   0
+#define UDI_CDC_COMM_STRING_ID_0   0
 #endif
 #ifndef UDI_CDC_DATA_STRING_ID_0
-  #define UDI_CDC_DATA_STRING_ID_0   0
+#define UDI_CDC_DATA_STRING_ID_0   0
 #endif
 #define UDI_CDC_IAD_DESC_0      UDI_CDC_IAD_DESC(0)
 #define UDI_CDC_COMM_DESC_0     UDI_CDC_COMM_DESC(0)
@@ -151,13 +151,13 @@ typedef struct {

 //! By default no string associated to these interfaces
 #ifndef UDI_CDC_IAD_STRING_ID_1
-  #define UDI_CDC_IAD_STRING_ID_1  0
+#define UDI_CDC_IAD_STRING_ID_1  0
 #endif
 #ifndef UDI_CDC_COMM_STRING_ID_1
-  #define UDI_CDC_COMM_STRING_ID_1 0
+#define UDI_CDC_COMM_STRING_ID_1 0
 #endif
 #ifndef UDI_CDC_DATA_STRING_ID_1
-  #define UDI_CDC_DATA_STRING_ID_1 0
+#define UDI_CDC_DATA_STRING_ID_1 0
 #endif
 #define UDI_CDC_IAD_DESC_1      UDI_CDC_IAD_DESC(1)
 #define UDI_CDC_COMM_DESC_1     UDI_CDC_COMM_DESC(1)
@@ -166,13 +166,13 @@ typedef struct {

 //! By default no string associated to these interfaces
 #ifndef UDI_CDC_IAD_STRING_ID_2
-  #define UDI_CDC_IAD_STRING_ID_2   0
+#define UDI_CDC_IAD_STRING_ID_2   0
 #endif
 #ifndef UDI_CDC_COMM_STRING_ID_2
-  #define UDI_CDC_COMM_STRING_ID_2  0
+#define UDI_CDC_COMM_STRING_ID_2   0
 #endif
 #ifndef UDI_CDC_DATA_STRING_ID_2
-  #define UDI_CDC_DATA_STRING_ID_2  0
+#define UDI_CDC_DATA_STRING_ID_2   0
 #endif
 #define UDI_CDC_IAD_DESC_2      UDI_CDC_IAD_DESC(2)
 #define UDI_CDC_COMM_DESC_2     UDI_CDC_COMM_DESC(2)
@@ -181,13 +181,13 @@ typedef struct {

 //! By default no string associated to these interfaces
 #ifndef UDI_CDC_IAD_STRING_ID_3
-  #define UDI_CDC_IAD_STRING_ID_3   0
+#define UDI_CDC_IAD_STRING_ID_3   0
 #endif
 #ifndef UDI_CDC_COMM_STRING_ID_3
-  #define UDI_CDC_COMM_STRING_ID_3  0
+#define UDI_CDC_COMM_STRING_ID_3   0
 #endif
 #ifndef UDI_CDC_DATA_STRING_ID_3
-  #define UDI_CDC_DATA_STRING_ID_3  0
+#define UDI_CDC_DATA_STRING_ID_3   0
 #endif
 #define UDI_CDC_IAD_DESC_3      UDI_CDC_IAD_DESC(3)
 #define UDI_CDC_COMM_DESC_3     UDI_CDC_COMM_DESC(3)
@@ -196,13 +196,13 @@ typedef struct {

 //! By default no string associated to these interfaces
 #ifndef UDI_CDC_IAD_STRING_ID_4
-  #define UDI_CDC_IAD_STRING_ID_4   0
+#define UDI_CDC_IAD_STRING_ID_4   0
 #endif
 #ifndef UDI_CDC_COMM_STRING_ID_4
-  #define UDI_CDC_COMM_STRING_ID_4  0
+#define UDI_CDC_COMM_STRING_ID_4   0
 #endif
 #ifndef UDI_CDC_DATA_STRING_ID_4
-  #define UDI_CDC_DATA_STRING_ID_4  0
+#define UDI_CDC_DATA_STRING_ID_4   0
 #endif
 #define UDI_CDC_IAD_DESC_4      UDI_CDC_IAD_DESC(4)
 #define UDI_CDC_COMM_DESC_4     UDI_CDC_COMM_DESC(4)
@@ -211,13 +211,13 @@ typedef struct {

 //! By default no string associated to these interfaces
 #ifndef UDI_CDC_IAD_STRING_ID_5
-  #define UDI_CDC_IAD_STRING_ID_5   0
+#define UDI_CDC_IAD_STRING_ID_5   0
 #endif
 #ifndef UDI_CDC_COMM_STRING_ID_5
-  #define UDI_CDC_COMM_STRING_ID_5  0
+#define UDI_CDC_COMM_STRING_ID_5   0
 #endif
 #ifndef UDI_CDC_DATA_STRING_ID_5
-  #define UDI_CDC_DATA_STRING_ID_5  0
+#define UDI_CDC_DATA_STRING_ID_5   0
 #endif
 #define UDI_CDC_IAD_DESC_5      UDI_CDC_IAD_DESC(5)
 #define UDI_CDC_COMM_DESC_5     UDI_CDC_COMM_DESC(5)
@@ -226,13 +226,13 @@ typedef struct {

 //! By default no string associated to these interfaces
 #ifndef UDI_CDC_IAD_STRING_ID_6
-  #define UDI_CDC_IAD_STRING_ID_6   0
+#define UDI_CDC_IAD_STRING_ID_6   0
 #endif
 #ifndef UDI_CDC_COMM_STRING_ID_6
-  #define UDI_CDC_COMM_STRING_ID_6  0
+#define UDI_CDC_COMM_STRING_ID_6   0
 #endif
 #ifndef UDI_CDC_DATA_STRING_ID_6
-  #define UDI_CDC_DATA_STRING_ID_6  0
+#define UDI_CDC_DATA_STRING_ID_6   0
 #endif
 #define UDI_CDC_IAD_DESC_6      UDI_CDC_IAD_DESC(6)
 #define UDI_CDC_COMM_DESC_6     UDI_CDC_COMM_DESC(6)
@@ -240,6 +240,7 @@ typedef struct {
 #define UDI_CDC_DATA_DESC_6_HS  UDI_CDC_DATA_DESC_HS(6)
 //@}

+
 //! Content of CDC IAD interface descriptor for all speeds
 #define UDI_CDC_IAD_DESC(port) { \
   .bLength                      = sizeof(usb_iad_desc_t),\
@@ -269,7 +270,7 @@ typedef struct {
   .call_mgmt.bDescriptorType    = CDC_CS_INTERFACE,\
   .call_mgmt.bDescriptorSubtype = CDC_SCS_CALL_MGMT,\
   .call_mgmt.bmCapabilities     = \
-      CDC_CALL_MGMT_SUPPORTED | CDC_CALL_MGMT_OVER_DCI,\
+			CDC_CALL_MGMT_SUPPORTED | CDC_CALL_MGMT_OVER_DCI,\
   .acm.bFunctionLength          = sizeof(usb_cdc_acm_desc_t),\
   .acm.bDescriptorType          = CDC_CS_INTERFACE,\
   .acm.bDescriptorSubtype       = CDC_SCS_ACM,\
@@ -609,37 +610,40 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
 * \subsection udi_cdc_basic_use_case_usage_code Example code
 * Content of conf_usb.h:
 * \code
-   #define UDI_CDC_ENABLE_EXT(port) my_callback_cdc_enable()
-   extern bool my_callback_cdc_enable(void);
-   #define UDI_CDC_DISABLE_EXT(port) my_callback_cdc_disable()
-   extern void my_callback_cdc_disable(void);
-   #define  UDI_CDC_LOW_RATE
+	 #define UDI_CDC_ENABLE_EXT(port) my_callback_cdc_enable()
+	 extern bool my_callback_cdc_enable(void);
+	 #define UDI_CDC_DISABLE_EXT(port) my_callback_cdc_disable()
+	 extern void my_callback_cdc_disable(void);
+	 #define  UDI_CDC_LOW_RATE

-   #define  UDI_CDC_DEFAULT_RATE             115200
-   #define  UDI_CDC_DEFAULT_STOPBITS         CDC_STOP_BITS_1
-   #define  UDI_CDC_DEFAULT_PARITY           CDC_PAR_NONE
-   #define  UDI_CDC_DEFAULT_DATABITS         8
+	 #define  UDI_CDC_DEFAULT_RATE             115200
+	 #define  UDI_CDC_DEFAULT_STOPBITS         CDC_STOP_BITS_1
+	 #define  UDI_CDC_DEFAULT_PARITY           CDC_PAR_NONE
+	 #define  UDI_CDC_DEFAULT_DATABITS         8

-   #include "udi_cdc_conf.h" // At the end of conf_usb.h file
+	 #include "udi_cdc_conf.h" // At the end of conf_usb.h file
 \endcode
 *
 * Add to application C-file:
 * \code
-  static bool my_flag_autorize_cdc_transfert = false;
-  bool my_callback_cdc_enable(void) {
-    my_flag_autorize_cdc_transfert = true;
-    return true;
-  }
-  void my_callback_cdc_disable(void) {
-    my_flag_autorize_cdc_transfert = false;
-  }
+	 static bool my_flag_autorize_cdc_transfert = false;
+	 bool my_callback_cdc_enable(void)
+	 {
+	    my_flag_autorize_cdc_transfert = true;
+	    return true;
+	 }
+	 void my_callback_cdc_disable(void)
+	 {
+	    my_flag_autorize_cdc_transfert = false;
+	 }

-  void task(void) {
-    if (my_flag_autorize_cdc_transfert) {
-      udi_cdc_putc('A');
-      udi_cdc_getc();
-    }
-  }
+	 void task(void)
+	 {
+	    if (my_flag_autorize_cdc_transfert) {
+	        udi_cdc_putc('A');
+	        udi_cdc_getc();
+	    }
+	 }
 \endcode
 *
 * \subsection udi_cdc_basic_use_case_setup_flow Workflow
@@ -648,14 +652,14 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
 *   - \code #define USB_DEVICE_SERIAL_NAME  "12...EF" // Disk SN for CDC \endcode
 *     \note The USB serial number is mandatory when a CDC interface is used.
 *   - \code #define UDI_CDC_ENABLE_EXT(port) my_callback_cdc_enable()
-   extern bool my_callback_cdc_enable(void); \endcode
+	 extern bool my_callback_cdc_enable(void); \endcode
 *     \note After the device enumeration (detecting and identifying USB devices),
 *     the USB host starts the device configuration. When the USB CDC interface
 *     from the device is accepted by the host, the USB host enables this interface and the
 *     UDI_CDC_ENABLE_EXT() callback function is called and return true.
 *     Thus, when this event is received, the data transfer on CDC interface are authorized.
 *   - \code #define UDI_CDC_DISABLE_EXT(port) my_callback_cdc_disable()
-   extern void my_callback_cdc_disable(void); \endcode
+	 extern void my_callback_cdc_disable(void); \endcode
 *     \note When the USB device is unplugged or is reset by the USB host, the USB
 *     interface is disabled and the UDI_CDC_DISABLE_EXT() callback function
 *     is called. Thus, the data transfer must be stopped on CDC interface.
@@ -663,19 +667,19 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
 *     \note  Define it when the transfer CDC Device to Host is a low rate
 *     (<512000 bauds) to reduce CDC buffers size.
 *   - \code #define  UDI_CDC_DEFAULT_RATE             115200
-  #define  UDI_CDC_DEFAULT_STOPBITS         CDC_STOP_BITS_1
-  #define  UDI_CDC_DEFAULT_PARITY           CDC_PAR_NONE
-  #define  UDI_CDC_DEFAULT_DATABITS         8 \endcode
+	#define  UDI_CDC_DEFAULT_STOPBITS         CDC_STOP_BITS_1
+	#define  UDI_CDC_DEFAULT_PARITY           CDC_PAR_NONE
+	#define  UDI_CDC_DEFAULT_DATABITS         8 \endcode
 *     \note Default configuration of communication port at startup.
 * -# Send or wait data on CDC line:
 *   - \code // Waits and gets a value on CDC line
-  int udi_cdc_getc(void);
-  // Reads a RAM buffer on CDC line
-  iram_size_t udi_cdc_read_buf(int *buf, iram_size_t size);
-  // Puts a byte on CDC line
-  int udi_cdc_putc(int value);
-  // Writes a RAM buffer on CDC line
-  iram_size_t udi_cdc_write_buf(const int *buf, iram_size_t size); \endcode
+	int udi_cdc_getc(void);
+	// Reads a RAM buffer on CDC line
+	iram_size_t udi_cdc_read_buf(int *buf, iram_size_t size);
+	// Puts a byte on CDC line
+	int udi_cdc_putc(int value);
+	// Writes a RAM buffer on CDC line
+	iram_size_t udi_cdc_write_buf(const int *buf, iram_size_t size); \endcode
 *
 * \section udi_cdc_use_cases Advanced use cases
 * For more advanced use of the UDI CDC module, see the following use cases:
@@ -709,90 +713,90 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
 * \subsection udi_cdc_use_case_composite_usage_code Example code
 * Content of conf_usb.h:
 * \code
-   #define USB_DEVICE_EP_CTRL_SIZE  64
-   #define USB_DEVICE_NB_INTERFACE (X+2)
-   #define USB_DEVICE_MAX_EP (X+3)
+	 #define USB_DEVICE_EP_CTRL_SIZE  64
+	 #define USB_DEVICE_NB_INTERFACE (X+2)
+	 #define USB_DEVICE_MAX_EP (X+3)

-   #define UDI_CDC_DATA_EP_IN_0         (1 | USB_EP_DIR_IN)  // TX
-   #define UDI_CDC_DATA_EP_OUT_0        (2 | USB_EP_DIR_OUT) // RX
-   #define UDI_CDC_COMM_EP_0            (3 | USB_EP_DIR_IN)  // Notify endpoint
-   #define UDI_CDC_COMM_IFACE_NUMBER_0  X+0
-   #define UDI_CDC_DATA_IFACE_NUMBER_0  X+1
+	 #define  UDI_CDC_DATA_EP_IN_0          (1 | USB_EP_DIR_IN)  // TX
+	 #define  UDI_CDC_DATA_EP_OUT_0         (2 | USB_EP_DIR_OUT) // RX
+	 #define  UDI_CDC_COMM_EP_0             (3 | USB_EP_DIR_IN)  // Notify endpoint
+	 #define  UDI_CDC_COMM_IFACE_NUMBER_0   X+0
+	 #define  UDI_CDC_DATA_IFACE_NUMBER_0   X+1

-   #define UDI_COMPOSITE_DESC_T \
-      usb_iad_desc_t udi_cdc_iad; \
-      udi_cdc_comm_desc_t udi_cdc_comm; \
-      udi_cdc_data_desc_t udi_cdc_data; \
-      ...
-   #define UDI_COMPOSITE_DESC_FS \
-      .udi_cdc_iad               = UDI_CDC_IAD_DESC_0, \
-      .udi_cdc_comm              = UDI_CDC_COMM_DESC_0, \
-      .udi_cdc_data              = UDI_CDC_DATA_DESC_0_FS, \
-      ...
-   #define UDI_COMPOSITE_DESC_HS \
-      .udi_cdc_iad               = UDI_CDC_IAD_DESC_0, \
-      .udi_cdc_comm              = UDI_CDC_COMM_DESC_0, \
-      .udi_cdc_data              = UDI_CDC_DATA_DESC_0_HS, \
-      ...
-   #define UDI_COMPOSITE_API \
-      &udi_api_cdc_comm,       \
-      &udi_api_cdc_data,       \
-      ...
+	 #define UDI_COMPOSITE_DESC_T \
+	    usb_iad_desc_t udi_cdc_iad; \
+	    udi_cdc_comm_desc_t udi_cdc_comm; \
+	    udi_cdc_data_desc_t udi_cdc_data; \
+	    ...
+	 #define UDI_COMPOSITE_DESC_FS \
+	    .udi_cdc_iad               = UDI_CDC_IAD_DESC_0, \
+	    .udi_cdc_comm              = UDI_CDC_COMM_DESC_0, \
+	    .udi_cdc_data              = UDI_CDC_DATA_DESC_0_FS, \
+	    ...
+	 #define UDI_COMPOSITE_DESC_HS \
+	    .udi_cdc_iad               = UDI_CDC_IAD_DESC_0, \
+	    .udi_cdc_comm              = UDI_CDC_COMM_DESC_0, \
+	    .udi_cdc_data              = UDI_CDC_DATA_DESC_0_HS, \
+	    ...
+	 #define UDI_COMPOSITE_API \
+	    &udi_api_cdc_comm,       \
+	    &udi_api_cdc_data,       \
+	    ...
 \endcode
 *
 * \subsection udi_cdc_use_case_composite_usage_flow Workflow
 * -# Ensure that conf_usb.h is available and contains the following parameters
 * required for a USB composite device configuration:
 *   - \code // Endpoint control size, This must be:
-  // - 8, 16, 32 or 64 for full speed device (8 is recommended to save RAM)
-  // - 64 for a high speed device
-  #define USB_DEVICE_EP_CTRL_SIZE  64
-  // Total Number of interfaces on this USB device.
-  // Add 2 for CDC.
-  #define USB_DEVICE_NB_INTERFACE (X+2)
-  // Total number of endpoints on this USB device.
-  // This must include each endpoint for each interface.
-  // Add 3 for CDC.
-  #define USB_DEVICE_MAX_EP (X+3) \endcode
+	// - 8, 16, 32 or 64 for full speed device (8 is recommended to save RAM)
+	// - 64 for a high speed device
+	#define USB_DEVICE_EP_CTRL_SIZE  64
+	// Total Number of interfaces on this USB device.
+	// Add 2 for CDC.
+	#define USB_DEVICE_NB_INTERFACE (X+2)
+	// Total number of endpoints on this USB device.
+	// This must include each endpoint for each interface.
+	// Add 3 for CDC.
+	#define USB_DEVICE_MAX_EP (X+3) \endcode
 * -# Ensure that conf_usb.h contains the description of
 * composite device:
 *   - \code // The endpoint numbers chosen by you for the CDC.
-  // The endpoint numbers starting from 1.
-  #define  UDI_CDC_DATA_EP_IN_0            (1 | USB_EP_DIR_IN)  // TX
-  #define  UDI_CDC_DATA_EP_OUT_0           (2 | USB_EP_DIR_OUT) // RX
-  #define  UDI_CDC_COMM_EP_0               (3 | USB_EP_DIR_IN)  // Notify endpoint
-  // The interface index of an interface starting from 0
-  #define  UDI_CDC_COMM_IFACE_NUMBER_0     X+0
-  #define  UDI_CDC_DATA_IFACE_NUMBER_0     X+1 \endcode
+	// The endpoint numbers starting from 1.
+	#define  UDI_CDC_DATA_EP_IN_0            (1 | USB_EP_DIR_IN)  // TX
+	#define  UDI_CDC_DATA_EP_OUT_0           (2 | USB_EP_DIR_OUT) // RX
+	#define  UDI_CDC_COMM_EP_0               (3 | USB_EP_DIR_IN)  // Notify endpoint
+	// The interface index of an interface starting from 0
+	#define  UDI_CDC_COMM_IFACE_NUMBER_0     X+0
+	#define  UDI_CDC_DATA_IFACE_NUMBER_0     X+1 \endcode
 * -# Ensure that conf_usb.h contains the following parameters
 * required for a USB composite device configuration:
 *   - \code // USB Interfaces descriptor structure
-  #define UDI_COMPOSITE_DESC_T \
-     ...
-     usb_iad_desc_t udi_cdc_iad; \
-     udi_cdc_comm_desc_t udi_cdc_comm; \
-     udi_cdc_data_desc_t udi_cdc_data; \
-     ...
-  // USB Interfaces descriptor value for Full Speed
-  #define UDI_COMPOSITE_DESC_FS \
-     ...
-     .udi_cdc_iad               = UDI_CDC_IAD_DESC_0, \
-     .udi_cdc_comm              = UDI_CDC_COMM_DESC_0, \
-     .udi_cdc_data              = UDI_CDC_DATA_DESC_0_FS, \
-     ...
-  // USB Interfaces descriptor value for High Speed
-  #define UDI_COMPOSITE_DESC_HS \
-     ...
-     .udi_cdc_iad               = UDI_CDC_IAD_DESC_0, \
-     .udi_cdc_comm              = UDI_CDC_COMM_DESC_0, \
-     .udi_cdc_data              = UDI_CDC_DATA_DESC_0_HS, \
-     ...
-  // USB Interface APIs
-  #define UDI_COMPOSITE_API \
-     ...
-     &udi_api_cdc_comm,       \
-     &udi_api_cdc_data,       \
-     ... \endcode
+	#define UDI_COMPOSITE_DESC_T \
+	   ...
+	   usb_iad_desc_t udi_cdc_iad; \
+	   udi_cdc_comm_desc_t udi_cdc_comm; \
+	   udi_cdc_data_desc_t udi_cdc_data; \
+	   ...
+	// USB Interfaces descriptor value for Full Speed
+	#define UDI_COMPOSITE_DESC_FS \
+	   ...
+	   .udi_cdc_iad               = UDI_CDC_IAD_DESC_0, \
+	   .udi_cdc_comm              = UDI_CDC_COMM_DESC_0, \
+	   .udi_cdc_data              = UDI_CDC_DATA_DESC_0_FS, \
+	   ...
+	// USB Interfaces descriptor value for High Speed
+	#define UDI_COMPOSITE_DESC_HS \
+	   ...
+	   .udi_cdc_iad               = UDI_CDC_IAD_DESC_0, \
+	   .udi_cdc_comm              = UDI_CDC_COMM_DESC_0, \
+	   .udi_cdc_data              = UDI_CDC_DATA_DESC_0_HS, \
+	   ...
+	// USB Interface APIs
+	#define UDI_COMPOSITE_API \
+	   ...
+	   &udi_api_cdc_comm,       \
+	   &udi_api_cdc_data,       \
+	   ... \endcode
 *   - \note The descriptors order given in the four lists above must be the
 *     same as the order defined by all interface indexes. The interface index
 *     orders are defined through UDI_X_IFACE_NUMBER defines.\n
@@ -51,7 +51,7 @@
 #include "udc_desc.h"
 #include "udi_cdc.h"

-#if !HAS_MEDIA
+#if DISABLED(SDSUPPORT)

 /**
 * \defgroup udi_cdc_group_single_desc USB device descriptors for a single interface
@@ -256,6 +256,6 @@ UDC_DESC_STORAGE udc_config_t udc_config = {
 //@}
 //@}

-#endif // HAS_MEDIA
+#endif // SDSUPPORT

 #endif // ARDUINO_ARCH_SAM
@@ -50,7 +50,7 @@
 #include "udd.h"
 #include "udc_desc.h"

-#if HAS_MEDIA
+#if ENABLED(SDSUPPORT)

 /**
 * \defgroup udi_group_desc Descriptors for a USB Device
@@ -189,4 +189,4 @@ UDC_DESC_STORAGE udc_config_t udc_config = {

 #endif // ARDUINO_ARCH_SAM

-#endif // HAS_MEDIA
+#endif // SDSUPPORT
@@ -57,7 +57,7 @@
 #include "ctrl_access.h"
 #include <string.h>

-#if HAS_MEDIA
+#if ENABLED(SDSUPPORT)

 #ifndef UDI_MSC_NOTIFY_TRANS_EXT
 #  define UDI_MSC_NOTIFY_TRANS_EXT()
@@ -372,7 +372,9 @@ static void udi_msc_sbc_trans(bool b_read);

 //@}

-bool udi_msc_enable(void) {
+
+bool udi_msc_enable(void)
+{
  uint8_t lun;
  udi_msc_b_trans_req = false;
  udi_msc_b_cbw_invalid = false;
@@ -395,14 +397,18 @@ bool udi_msc_enable(void) {
  return true;
 }

-void udi_msc_disable(void) {
+
+void udi_msc_disable(void)
+{
  udi_msc_b_trans_req = false;
  udi_msc_b_ack_trans = true;
  udi_msc_b_reset_trans = true;
  UDI_MSC_DISABLE_EXT();
 }

-bool udi_msc_setup(void) {
+
+bool udi_msc_setup(void)
+{
  if (Udd_setup_is_in()) {
    // Requests Interface GET
    if (Udd_setup_type() == USB_REQ_TYPE_CLASS) {
@@ -445,14 +451,17 @@ bool udi_msc_setup(void) {
  return false; // Not supported request
 }

-uint8_t udi_msc_getsetting(void) {
+uint8_t udi_msc_getsetting(void)
+{
  return 0; // MSC don't have multiple alternate setting
 }

+
 // ------------------------
 //------- Routines to process CBW packet

-static void udi_msc_cbw_invalid(void) {
+static void udi_msc_cbw_invalid(void)
+{
  if (!udi_msc_b_cbw_invalid)
    return; // Don't re-stall endpoint if error reset by setup
  udd_ep_set_halt(UDI_MSC_EP_OUT);
@@ -460,7 +469,8 @@ static void udi_msc_cbw_invalid(void) {
  udd_ep_wait_stall_clear(UDI_MSC_EP_OUT, udi_msc_cbw_invalid);
 }

-static void udi_msc_csw_invalid(void) {
+static void udi_msc_csw_invalid(void)
+{
  if (!udi_msc_b_cbw_invalid)
    return; // Don't re-stall endpoint if error reset by setup
  udd_ep_set_halt(UDI_MSC_EP_IN);
@@ -468,7 +478,8 @@ static void udi_msc_csw_invalid(void) {
  udd_ep_wait_stall_clear(UDI_MSC_EP_IN, udi_msc_csw_invalid);
 }

-static void udi_msc_cbw_wait(void) {
+static void udi_msc_cbw_wait(void)
+{
  // Register buffer and callback on OUT endpoint
  if (!udd_ep_run(UDI_MSC_EP_OUT, true,
          (uint8_t *) & udi_msc_cbw,
@@ -479,8 +490,10 @@ static void udi_msc_cbw_wait(void) {
  }
 }

+
 static void udi_msc_cbw_received(udd_ep_status_t status,
-    iram_size_t nb_received, udd_ep_id_t ep) {
+    iram_size_t nb_received, udd_ep_id_t ep)
+{
  UNUSED(ep);
  // Check status of transfer
  if (UDD_EP_TRANSFER_OK != status) {
@@ -569,7 +582,9 @@ static void udi_msc_cbw_received(udd_ep_status_t status,
  }
 }

-static bool udi_msc_cbw_validate(uint32_t alloc_len, uint8_t dir_flag) {
+
+static bool udi_msc_cbw_validate(uint32_t alloc_len, uint8_t dir_flag)
+{
  /*
   * The following cases should result in a phase error:
   *  - Case  2: Hn < Di
@@ -597,10 +612,12 @@ static bool udi_msc_cbw_validate(uint32_t alloc_len, uint8_t dir_flag) {
  return true;
 }

+
 // ------------------------
 //------- Routines to process small data packet

-static void udi_msc_data_send(uint8_t * buffer, uint8_t buf_size) {
+static void udi_msc_data_send(uint8_t * buffer, uint8_t buf_size)
+{
  // Sends data on IN endpoint
  if (!udd_ep_run(UDI_MSC_EP_IN, true,
          buffer, buf_size, udi_msc_data_sent)) {
@@ -610,8 +627,10 @@ static void udi_msc_data_send(uint8_t * buffer, uint8_t buf_size) {
  }
 }

+
 static void udi_msc_data_sent(udd_ep_status_t status, iram_size_t nb_sent,
-    udd_ep_id_t ep) {
+    udd_ep_id_t ep)
+{
  UNUSED(ep);
  if (UDD_EP_TRANSFER_OK != status) {
    // Error protocol
@@ -625,10 +644,12 @@ static void udi_msc_data_sent(udd_ep_status_t status, iram_size_t nb_sent,
  udi_msc_csw_process();
 }

+
 // ------------------------
 //------- Routines to process CSW packet

-static void udi_msc_csw_process(void) {
+static void udi_msc_csw_process(void)
+{
  if (0 != udi_msc_csw.dCSWDataResidue) {
    // Residue not NULL
    // then STALL next request from USB host on corresponding endpoint
@@ -643,7 +664,9 @@ static void udi_msc_csw_process(void) {
  udi_msc_csw_send();
 }

-void udi_msc_csw_send(void) {
+
+void udi_msc_csw_send(void)
+{
  // Sends CSW on IN endpoint
  if (!udd_ep_run(UDI_MSC_EP_IN, false,
          (uint8_t *) & udi_msc_csw,
@@ -655,8 +678,10 @@ void udi_msc_csw_send(void) {
  }
 }

+
 static void udi_msc_csw_sent(udd_ep_status_t status, iram_size_t nb_sent,
-    udd_ep_id_t ep) {
+    udd_ep_id_t ep)
+{
  UNUSED(ep);
  UNUSED(status);
  UNUSED(nb_sent);
@@ -665,17 +690,20 @@ static void udi_msc_csw_sent(udd_ep_status_t status, iram_size_t nb_sent,
  udi_msc_cbw_wait();
 }

+
 // ------------------------
 //------- Routines manage sense data

-static void udi_msc_clear_sense(void) {
+static void udi_msc_clear_sense(void)
+{
  memset((uint8_t*)&udi_msc_sense, 0, sizeof(struct scsi_request_sense_data));
  udi_msc_sense.valid_reponse_code = SCSI_SENSE_VALID | SCSI_SENSE_CURRENT;
  udi_msc_sense.AddSenseLen = SCSI_SENSE_ADDL_LEN(sizeof(udi_msc_sense));
 }

 static void udi_msc_sense_fail(uint8_t sense_key, uint16_t add_sense,
-    uint32_t lba) {
+    uint32_t lba)
+{
  udi_msc_clear_sense();
  udi_msc_csw.bCSWStatus = USB_CSW_STATUS_FAIL;
  udi_msc_sense.sense_flag_key = sense_key;
@@ -687,39 +715,53 @@ static void udi_msc_sense_fail(uint8_t sense_key, uint16_t add_sense,
  udi_msc_sense.AddSnsCodeQlfr = add_sense;
 }

-static void udi_msc_sense_pass(void) {
+static void udi_msc_sense_pass(void)
+{
  udi_msc_clear_sense();
  udi_msc_csw.bCSWStatus = USB_CSW_STATUS_PASS;
 }

-static void udi_msc_sense_fail_not_present(void) {
+
+static void udi_msc_sense_fail_not_present(void)
+{
  udi_msc_sense_fail(SCSI_SK_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT, 0);
 }

-static void udi_msc_sense_fail_busy_or_change(void) {
-  udi_msc_sense_fail(SCSI_SK_UNIT_ATTENTION, SCSI_ASC_NOT_READY_TO_READY_CHANGE, 0);
+static void udi_msc_sense_fail_busy_or_change(void)
+{
+  udi_msc_sense_fail(SCSI_SK_UNIT_ATTENTION,
+      SCSI_ASC_NOT_READY_TO_READY_CHANGE, 0);
 }

-static void udi_msc_sense_fail_hardware(void) {
-  udi_msc_sense_fail(SCSI_SK_HARDWARE_ERROR, SCSI_ASC_NO_ADDITIONAL_SENSE_INFO, 0);
+static void udi_msc_sense_fail_hardware(void)
+{
+  udi_msc_sense_fail(SCSI_SK_HARDWARE_ERROR,
+      SCSI_ASC_NO_ADDITIONAL_SENSE_INFO, 0);
 }

-static void udi_msc_sense_fail_protected(void) {
+static void udi_msc_sense_fail_protected(void)
+{
  udi_msc_sense_fail(SCSI_SK_DATA_PROTECT, SCSI_ASC_WRITE_PROTECTED, 0);
 }

-static void udi_msc_sense_fail_cdb_invalid(void) {
-  udi_msc_sense_fail(SCSI_SK_ILLEGAL_REQUEST, SCSI_ASC_INVALID_FIELD_IN_CDB, 0);
+static void udi_msc_sense_fail_cdb_invalid(void)
+{
+  udi_msc_sense_fail(SCSI_SK_ILLEGAL_REQUEST,
+      SCSI_ASC_INVALID_FIELD_IN_CDB, 0);
 }

-static void udi_msc_sense_command_invalid(void) {
-  udi_msc_sense_fail(SCSI_SK_ILLEGAL_REQUEST, SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 0);
+static void udi_msc_sense_command_invalid(void)
+{
+  udi_msc_sense_fail(SCSI_SK_ILLEGAL_REQUEST,
+      SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 0);
 }

+
 // ------------------------
 //------- Routines manage SCSI Commands

-static void udi_msc_spc_requestsense(void) {
+static void udi_msc_spc_requestsense(void)
+{
  uint8_t length = udi_msc_cbw.CDB[4];

  // Can't send more than sense data length
@@ -732,7 +774,9 @@ static void udi_msc_spc_requestsense(void) {
  udi_msc_data_send((uint8_t*)&udi_msc_sense, length);
 }

-static void udi_msc_spc_inquiry(void) {
+
+static void udi_msc_spc_inquiry(void)
+{
  uint8_t length, i;
  UDC_DATA(4)
  // Constant inquiry data for all LUNs
@@ -791,7 +835,9 @@ static void udi_msc_spc_inquiry(void) {
  udi_msc_data_send((uint8_t *) & udi_msc_inquiry_data, length);
 }

-static bool udi_msc_spc_testunitready_global(void) {
+
+static bool udi_msc_spc_testunitready_global(void)
+{
  switch (mem_test_unit_ready(udi_msc_cbw.bCBWLUN)) {
  case CTRL_GOOD:
    return true;  // Don't change sense data
@@ -809,7 +855,9 @@ static bool udi_msc_spc_testunitready_global(void) {
  return false;
 }

-static void udi_msc_spc_testunitready(void) {
+
+static void udi_msc_spc_testunitready(void)
+{
  if (udi_msc_spc_testunitready_global()) {
    // LUN ready, then update sense data with status pass
    udi_msc_sense_pass();
@@ -818,7 +866,9 @@ static void udi_msc_spc_testunitready(void) {
  udi_msc_csw_process();
 }

-static void udi_msc_spc_mode_sense(bool b_sense10) {
+
+static void udi_msc_spc_mode_sense(bool b_sense10)
+{
  // Union of all mode sense structures
  union sense_6_10 {
    struct {
@@ -893,7 +943,9 @@ static void udi_msc_spc_mode_sense(bool b_sense10) {
  udi_msc_data_send((uint8_t *) & sense, request_lgt);
 }

-static void udi_msc_spc_prevent_allow_medium_removal(void) {
+
+static void udi_msc_spc_prevent_allow_medium_removal(void)
+{
  uint8_t prevent = udi_msc_cbw.CDB[4];
  if (0 == prevent) {
    udi_msc_sense_pass();
@@ -903,7 +955,9 @@ static void udi_msc_spc_prevent_allow_medium_removal(void) {
  udi_msc_csw_process();
 }

-static void udi_msc_sbc_start_stop(void) {
+
+static void udi_msc_sbc_start_stop(void)
+{
  bool start = 0x1 & udi_msc_cbw.CDB[4];
  bool loej = 0x2 & udi_msc_cbw.CDB[4];
  if (loej) {
@@ -913,7 +967,9 @@ static void udi_msc_sbc_start_stop(void) {
  udi_msc_csw_process();
 }

-static void udi_msc_sbc_read_capacity(void) {
+
+static void udi_msc_sbc_read_capacity(void)
+{
  UDC_BSS(4) static struct sbc_read_capacity10_data udi_msc_capacity;

  if (!udi_msc_cbw_validate(sizeof(udi_msc_capacity),
@@ -947,7 +1003,9 @@ static void udi_msc_sbc_read_capacity(void) {
      sizeof(udi_msc_capacity));
 }

-static void udi_msc_sbc_trans(bool b_read) {
+
+static void udi_msc_sbc_trans(bool b_read)
+{
  uint32_t trans_size;

  if (!b_read) {
@@ -980,7 +1038,9 @@ static void udi_msc_sbc_trans(bool b_read) {
  UDI_MSC_NOTIFY_TRANS_EXT();
 }

-bool udi_msc_process_trans(void) {
+
+bool udi_msc_process_trans(void)
+{
  Ctrl_status status;

  if (!udi_msc_b_trans_req)
@@ -1024,8 +1084,10 @@ bool udi_msc_process_trans(void) {
  return true;
 }

+
 static void udi_msc_trans_ack(udd_ep_status_t status, iram_size_t n,
-    udd_ep_id_t ep) {
+    udd_ep_id_t ep)
+{
  UNUSED(ep);
  UNUSED(n);
  // Update variable to signal the end of transfer
@@ -1033,8 +1095,10 @@ static void udi_msc_trans_ack(udd_ep_status_t status, iram_size_t n,
  udi_msc_b_ack_trans = true;
 }

+
 bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
-    void (*callback) (udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep)) {
+    void (*callback) (udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep))
+{
  if (!udi_msc_b_ack_trans)
    return false; // No possible, transfer on going

@@ -1063,6 +1127,6 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,

 //@}

-#endif // HAS_MEDIA
+#endif // SDSUPPORT

 #endif // ARDUINO_ARCH_SAM
@@ -77,9 +77,9 @@ extern UDC_DESC_STORAGE udi_api_t udi_api_msc;

 //! Interface descriptor structure for MSC
 typedef struct {
-  usb_iface_desc_t iface;
-  usb_ep_desc_t ep_in;
-  usb_ep_desc_t ep_out;
+	usb_iface_desc_t iface;
+	usb_ep_desc_t ep_in;
+	usb_ep_desc_t ep_out;
 } udi_msc_desc_t;

 //! By default no string associated to this interface
@@ -94,32 +94,32 @@ typedef struct {

 //! Content of MSC interface descriptor for all speeds
 #define UDI_MSC_DESC      \
-  .iface.bLength             = sizeof(usb_iface_desc_t),\
-  .iface.bDescriptorType     = USB_DT_INTERFACE,\
-  .iface.bInterfaceNumber    = UDI_MSC_IFACE_NUMBER,\
-  .iface.bAlternateSetting   = 0,\
-  .iface.bNumEndpoints       = 2,\
-  .iface.bInterfaceClass     = MSC_CLASS,\
-  .iface.bInterfaceSubClass  = MSC_SUBCLASS_TRANSPARENT,\
-  .iface.bInterfaceProtocol  = MSC_PROTOCOL_BULK,\
-  .iface.iInterface          = UDI_MSC_STRING_ID,\
-  .ep_in.bLength             = sizeof(usb_ep_desc_t),\
-  .ep_in.bDescriptorType     = USB_DT_ENDPOINT,\
-  .ep_in.bEndpointAddress    = UDI_MSC_EP_IN,\
-  .ep_in.bmAttributes        = USB_EP_TYPE_BULK,\
-  .ep_in.bInterval           = 0,\
-  .ep_out.bLength            = sizeof(usb_ep_desc_t),\
-  .ep_out.bDescriptorType    = USB_DT_ENDPOINT,\
-  .ep_out.bEndpointAddress   = UDI_MSC_EP_OUT,\
-  .ep_out.bmAttributes       = USB_EP_TYPE_BULK,\
-  .ep_out.bInterval          = 0,
+   .iface.bLength             = sizeof(usb_iface_desc_t),\
+   .iface.bDescriptorType     = USB_DT_INTERFACE,\
+   .iface.bInterfaceNumber    = UDI_MSC_IFACE_NUMBER,\
+   .iface.bAlternateSetting   = 0,\
+   .iface.bNumEndpoints       = 2,\
+   .iface.bInterfaceClass     = MSC_CLASS,\
+   .iface.bInterfaceSubClass  = MSC_SUBCLASS_TRANSPARENT,\
+   .iface.bInterfaceProtocol  = MSC_PROTOCOL_BULK,\
+   .iface.iInterface          = UDI_MSC_STRING_ID,\
+   .ep_in.bLength             = sizeof(usb_ep_desc_t),\
+   .ep_in.bDescriptorType     = USB_DT_ENDPOINT,\
+   .ep_in.bEndpointAddress    = UDI_MSC_EP_IN,\
+   .ep_in.bmAttributes        = USB_EP_TYPE_BULK,\
+   .ep_in.bInterval           = 0,\
+   .ep_out.bLength            = sizeof(usb_ep_desc_t),\
+   .ep_out.bDescriptorType    = USB_DT_ENDPOINT,\
+   .ep_out.bEndpointAddress   = UDI_MSC_EP_OUT,\
+   .ep_out.bmAttributes       = USB_EP_TYPE_BULK,\
+   .ep_out.bInterval          = 0,

 //! Content of MSC interface descriptor for full speed only
 #define UDI_MSC_DESC_FS   {\
-  UDI_MSC_DESC \
-  .ep_in.wMaxPacketSize      = LE16(UDI_MSC_EPS_SIZE_FS),\
-  .ep_out.wMaxPacketSize     = LE16(UDI_MSC_EPS_SIZE_FS),\
-  }
+   UDI_MSC_DESC \
+   .ep_in.wMaxPacketSize      = LE16(UDI_MSC_EPS_SIZE_FS),\
+   .ep_out.wMaxPacketSize     = LE16(UDI_MSC_EPS_SIZE_FS),\
+   }

 //! Content of MSC interface descriptor for high speed only
 #define UDI_MSC_DESC_HS   {\
@@ -129,6 +129,7 @@ typedef struct {
   }
 //@}

+
 /**
 * \ingroup udi_group
 * \defgroup udi_msc_group USB Device Interface (UDI) for Mass Storage Class (MSC)
@@ -162,13 +163,14 @@ bool udi_msc_process_trans(void);
 * \return \c 1 if function was successfully done, otherwise \c 0.
 */
 bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
-    void (*callback) (udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep));
+		void (*callback) (udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep));
 //@}

 #ifdef __cplusplus
 }
 #endif

+
 /**
 * \page udi_msc_quickstart Quick start guide for USB device Mass Storage module (UDI MSC)
 *
@@ -198,32 +200,35 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
 * \subsection udi_msc_basic_use_case_usage_code Example code
 * Content of conf_usb.h:
 * \code
-  #define  USB_DEVICE_SERIAL_NAME  "12...EF" // Disk SN for MSC
-  #define UDI_MSC_GLOBAL_VENDOR_ID \
-     'A', 'T', 'M', 'E', 'L', ' ', ' ', ' '
-  #define UDI_MSC_GLOBAL_PRODUCT_VERSION \
-     '1', '.', '0', '0'
-  #define UDI_MSC_ENABLE_EXT() my_callback_msc_enable()
-  extern bool my_callback_msc_enable(void);
-  #define UDI_MSC_DISABLE_EXT() my_callback_msc_disable()
-  extern void my_callback_msc_disable(void);
-  #include "udi_msc_conf.h" // At the end of conf_usb.h file
+	#define  USB_DEVICE_SERIAL_NAME  "12...EF" // Disk SN for MSC
+	#define UDI_MSC_GLOBAL_VENDOR_ID \
+	   'A', 'T', 'M', 'E', 'L', ' ', ' ', ' '
+	#define UDI_MSC_GLOBAL_PRODUCT_VERSION \
+	   '1', '.', '0', '0'
+	#define UDI_MSC_ENABLE_EXT() my_callback_msc_enable()
+	extern bool my_callback_msc_enable(void);
+	#define UDI_MSC_DISABLE_EXT() my_callback_msc_disable()
+	extern void my_callback_msc_disable(void);
+	#include "udi_msc_conf.h" // At the end of conf_usb.h file
 \endcode
 *
 * Add to application C-file:
 * \code
-  static bool my_flag_autorize_msc_transfert = false;
-  bool my_callback_msc_enable(void) {
-    my_flag_autorize_msc_transfert = true;
-    return true;
-  }
-  void my_callback_msc_disable(void) {
-    my_flag_autorize_msc_transfert = false;
-  }
+	 static bool my_flag_autorize_msc_transfert = false;
+	 bool my_callback_msc_enable(void)
+	 {
+	    my_flag_autorize_msc_transfert = true;
+	    return true;
+	 }
+	 void my_callback_msc_disable(void)
+	 {
+	    my_flag_autorize_msc_transfert = false;
+	 }

-  void task(void) {
-    udi_msc_process_trans();
-  }
+	 void task(void)
+	 {
+	    udi_msc_process_trans();
+	 }
 \endcode
 *
 * \subsection udi_msc_basic_use_case_setup_flow Workflow
@@ -232,14 +237,14 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
 *   - \code #define USB_DEVICE_SERIAL_NAME  "12...EF" // Disk SN for MSC \endcode
 *     \note The USB serial number is mandatory when a MSC interface is used.
 *   - \code //! Vendor name and Product version of MSC interface
-  #define UDI_MSC_GLOBAL_VENDOR_ID \
-     'A', 'T', 'M', 'E', 'L', ' ', ' ', ' '
-  #define UDI_MSC_GLOBAL_PRODUCT_VERSION \
-     '1', '.', '0', '0' \endcode
+	#define UDI_MSC_GLOBAL_VENDOR_ID \
+	   'A', 'T', 'M', 'E', 'L', ' ', ' ', ' '
+	#define UDI_MSC_GLOBAL_PRODUCT_VERSION \
+	   '1', '.', '0', '0' \endcode
 *     \note The USB MSC interface requires a vendor ID (8 ASCII characters)
 *     and a product version (4 ASCII characters).
 *   - \code #define UDI_MSC_ENABLE_EXT() my_callback_msc_enable()
-  extern bool my_callback_msc_enable(void); \endcode
+	extern bool my_callback_msc_enable(void); \endcode
 *     \note After the device enumeration (detecting and identifying USB devices),
 *     the USB host starts the device configuration. When the USB MSC interface
 *     from the device is accepted by the host, the USB host enables this interface and the
@@ -247,7 +252,7 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
 *     Thus, when this event is received, the tasks which call
 *     udi_msc_process_trans() must be enabled.
 *   - \code #define UDI_MSC_DISABLE_EXT() my_callback_msc_disable()
-  extern void my_callback_msc_disable(void); \endcode
+	extern void my_callback_msc_disable(void); \endcode
 *     \note When the USB device is unplugged or is reset by the USB host, the USB
 *     interface is disabled and the UDI_MSC_DISABLE_EXT() callback function
 *     is called. Thus, it is recommended to disable the task which is called udi_msc_process_trans().
@@ -256,15 +261,15 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
 * must be done outside USB interrupt routine. This is done in the MSC process
 * ("udi_msc_process_trans()") called by main loop:
 *   - \code  * void task(void) {
-  udi_msc_process_trans();
-  } \endcode
+	udi_msc_process_trans();
+	} \endcode
 * -# The MSC speed depends on task periodicity. To get the best speed
 * the notification callback "UDI_MSC_NOTIFY_TRANS_EXT" can be used to wakeup
 * this task (Example, through a mutex):
 *   - \code #define  UDI_MSC_NOTIFY_TRANS_EXT()    msc_notify_trans()
-  void msc_notify_trans(void) {
-  wakeup_my_task();
-  } \endcode
+	void msc_notify_trans(void) {
+	wakeup_my_task();
+	} \endcode
 *
 * \section udi_msc_use_cases Advanced use cases
 * For more advanced use of the UDI MSC module, see the following use cases:
@@ -297,72 +302,72 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
 * \subsection udi_msc_use_case_composite_usage_code Example code
 * Content of conf_usb.h:
 * \code
-   #define USB_DEVICE_EP_CTRL_SIZE  64
-   #define USB_DEVICE_NB_INTERFACE (X+1)
-   #define USB_DEVICE_MAX_EP (X+2)
+	 #define USB_DEVICE_EP_CTRL_SIZE  64
+	 #define USB_DEVICE_NB_INTERFACE (X+1)
+	 #define USB_DEVICE_MAX_EP (X+2)

-   #define UDI_MSC_EP_IN  (X | USB_EP_DIR_IN)
-   #define UDI_MSC_EP_OUT (Y | USB_EP_DIR_OUT)
-   #define UDI_MSC_IFACE_NUMBER  X
+	 #define UDI_MSC_EP_IN  (X | USB_EP_DIR_IN)
+	 #define UDI_MSC_EP_OUT (Y | USB_EP_DIR_OUT)
+	 #define UDI_MSC_IFACE_NUMBER  X

-   #define UDI_COMPOSITE_DESC_T \
-      udi_msc_desc_t udi_msc; \
-      ...
-   #define UDI_COMPOSITE_DESC_FS \
-      .udi_msc = UDI_MSC_DESC, \
-      ...
-   #define UDI_COMPOSITE_DESC_HS \
-      .udi_msc = UDI_MSC_DESC, \
-      ...
-   #define UDI_COMPOSITE_API \
-      &udi_api_msc, \
-      ...
+	 #define UDI_COMPOSITE_DESC_T \
+	    udi_msc_desc_t udi_msc; \
+	    ...
+	 #define UDI_COMPOSITE_DESC_FS \
+	    .udi_msc = UDI_MSC_DESC, \
+	    ...
+	 #define UDI_COMPOSITE_DESC_HS \
+	    .udi_msc = UDI_MSC_DESC, \
+	    ...
+	 #define UDI_COMPOSITE_API \
+	    &udi_api_msc, \
+	    ...
 \endcode
 *
 * \subsection udi_msc_use_case_composite_usage_flow Workflow
 * -# Ensure that conf_usb.h is available and contains the following parameters
 * required for a USB composite device configuration:
 *   - \code // Endpoint control size, This must be:
-  // - 8, 16, 32 or 64 for full speed device (8 is recommended to save RAM)
-  // - 64 for a high speed device
-  #define USB_DEVICE_EP_CTRL_SIZE  64
-  // Total Number of interfaces on this USB device.
-  // Add 1 for MSC.
-  #define USB_DEVICE_NB_INTERFACE (X+1)
-  // Total number of endpoints on this USB device.
-  // This must include each endpoint for each interface.
-  // Add 2 for MSC.
-  #define USB_DEVICE_MAX_EP (X+2) \endcode
+	// - 8, 16, 32 or 64 for full speed device (8 is recommended to save RAM)
+	// - 64 for a high speed device
+	#define USB_DEVICE_EP_CTRL_SIZE  64
+	// Total Number of interfaces on this USB device.
+	// Add 1 for MSC.
+	#define USB_DEVICE_NB_INTERFACE (X+1)
+	// Total number of endpoints on this USB device.
+	// This must include each endpoint for each interface.
+	// Add 2 for MSC.
+	#define USB_DEVICE_MAX_EP (X+2) \endcode
 * -# Ensure that conf_usb.h contains the description of
 * composite device:
 *   - \code // The endpoint numbers chosen by you for the MSC.
-  // The endpoint numbers starting from 1.
-  #define UDI_MSC_EP_IN  (X | USB_EP_DIR_IN)
-  #define UDI_MSC_EP_OUT (Y | USB_EP_DIR_OUT)
-  // The interface index of an interface starting from 0
-  #define UDI_MSC_IFACE_NUMBER  X \endcode
+	// The endpoint numbers starting from 1.
+	#define UDI_MSC_EP_IN  (X | USB_EP_DIR_IN)
+	#define UDI_MSC_EP_OUT (Y | USB_EP_DIR_OUT)
+	// The interface index of an interface starting from 0
+	#define UDI_MSC_IFACE_NUMBER  X \endcode
 * -# Ensure that conf_usb.h contains the following parameters
 * required for a USB composite device configuration:
 *   - \code // USB Interfaces descriptor structure
-  #define UDI_COMPOSITE_DESC_T \
-     ...
-     udi_msc_desc_t udi_msc; \
-     ...
-  // USB Interfaces descriptor value for Full Speed
-  #define UDI_COMPOSITE_DESC_FS \
-     ...
-     .udi_msc = UDI_MSC_DESC_FS, \
-     ...
-  // USB Interfaces descriptor value for High Speed
-  #define UDI_COMPOSITE_DESC_HS \
-     ...
-     .udi_msc = UDI_MSC_DESC_HS, \
-     ...
-  // USB Interface APIs
-  #define UDI_COMPOSITE_API \
-     ...
-     &udi_api_msc, \
-     ... \endcode
+	#define UDI_COMPOSITE_DESC_T \
+	   ...
+	   udi_msc_desc_t udi_msc; \
+	   ...
+	// USB Interfaces descriptor value for Full Speed
+	#define UDI_COMPOSITE_DESC_FS \
+	   ...
+	   .udi_msc = UDI_MSC_DESC_FS, \
+	   ...
+	// USB Interfaces descriptor value for High Speed
+	#define UDI_COMPOSITE_DESC_HS \
+	   ...
+	   .udi_msc = UDI_MSC_DESC_HS, \
+	   ...
+	// USB Interface APIs
+	#define UDI_COMPOSITE_API \
+	   ...
+	   &udi_api_msc, \
+	   ... \endcode
 *   - \note The descriptors order given in the four lists above must be the
 *     same as the order defined by all interface indexes. The interface index
 *     orders are defined through UDI_X_IFACE_NUMBER defines.
@@ -127,13 +127,13 @@ void otg_dual_disable(void);
 //! These macros allows to enable/disable pad and UOTGHS hardware
 //! @{
  //! Reset USB macro
-#define otg_reset()                      \
-  do {                                   \
-    UOTGHS->UOTGHS_CTRL = 0;             \
-    while( UOTGHS->UOTGHS_SR & 0x3FFF) { \
-      UOTGHS->UOTGHS_SCR = 0xFFFFFFFF;   \
-    }                                    \
-  } while (0)
+#define otg_reset()                         \
+	do {                                    \
+		UOTGHS->UOTGHS_CTRL = 0;            \
+		while( UOTGHS->UOTGHS_SR & 0x3FFF) {\
+			UOTGHS->UOTGHS_SCR = 0xFFFFFFFF;\
+		}                                   \
+	} while (0)
  //! Enable USB macro
 #define otg_enable()                        (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_USBE))
  //! Disable USB macro
@@ -157,14 +157,15 @@ void otg_dual_disable(void);

  //! Configure time-out of specified OTG timer
 #define otg_configure_timeout(timer, timeout) (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK),\
-    Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMPAGE_Msk, timer),\
-    Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMVALUE_Msk, timeout),\
-    Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK))
+		Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMPAGE_Msk, timer),\
+		Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMVALUE_Msk, timeout),\
+		Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK))
  //! Get configured time-out of specified OTG timer
 #define otg_get_timeout(timer)              (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK),\
-    Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMPAGE_Msk, timer),\
-    Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK),\
-    Rd_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMVALUE_Msk))
+		Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMPAGE_Msk, timer),\
+		Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK),\
+		Rd_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMVALUE_Msk))
+

  //! Get the dual-role device state of the internal USB finite state machine of the UOTGHS controller
 #define otg_get_fsm_drd_state()             (Rd_bitfield(UOTGHS->UOTGHS_FSM, UOTGHS_FSM_DRDSTATE_Msk))
@@ -108,17 +108,17 @@
 * \brief Standard USB requests (bRequest)
 */
 enum usb_reqid {
-  USB_REQ_GET_STATUS = 0,
-  USB_REQ_CLEAR_FEATURE = 1,
-  USB_REQ_SET_FEATURE = 3,
-  USB_REQ_SET_ADDRESS = 5,
-  USB_REQ_GET_DESCRIPTOR = 6,
-  USB_REQ_SET_DESCRIPTOR = 7,
-  USB_REQ_GET_CONFIGURATION = 8,
-  USB_REQ_SET_CONFIGURATION = 9,
-  USB_REQ_GET_INTERFACE = 10,
-  USB_REQ_SET_INTERFACE = 11,
-  USB_REQ_SYNCH_FRAME = 12,
+	USB_REQ_GET_STATUS = 0,
+	USB_REQ_CLEAR_FEATURE = 1,
+	USB_REQ_SET_FEATURE = 3,
+	USB_REQ_SET_ADDRESS = 5,
+	USB_REQ_GET_DESCRIPTOR = 6,
+	USB_REQ_SET_DESCRIPTOR = 7,
+	USB_REQ_GET_CONFIGURATION = 8,
+	USB_REQ_SET_CONFIGURATION = 9,
+	USB_REQ_GET_INTERFACE = 10,
+	USB_REQ_SET_INTERFACE = 11,
+	USB_REQ_SYNCH_FRAME = 12,
 };

 /**
@@ -126,9 +126,9 @@ enum usb_reqid {
 *
 */
 enum usb_device_status {
-  USB_DEV_STATUS_BUS_POWERED = 0,
-  USB_DEV_STATUS_SELF_POWERED = 1,
-  USB_DEV_STATUS_REMOTEWAKEUP = 2
+	USB_DEV_STATUS_BUS_POWERED = 0,
+	USB_DEV_STATUS_SELF_POWERED = 1,
+	USB_DEV_STATUS_REMOTEWAKEUP = 2
 };

 /**
@@ -136,7 +136,7 @@ enum usb_device_status {
 *
 */
 enum usb_interface_status {
-  USB_IFACE_STATUS_RESERVED = 0
+	USB_IFACE_STATUS_RESERVED = 0
 };

 /**
@@ -144,7 +144,7 @@ enum usb_interface_status {
 *
 */
 enum usb_endpoint_status {
-  USB_EP_STATUS_HALTED = 1,
+	USB_EP_STATUS_HALTED = 1,
 };

 /**
@@ -153,11 +153,11 @@ enum usb_endpoint_status {
 * \note valid for SetFeature request.
 */
 enum usb_device_feature {
-  USB_DEV_FEATURE_REMOTE_WAKEUP = 1, //!< Remote wakeup enabled
-  USB_DEV_FEATURE_TEST_MODE = 2,     //!< USB test mode
-  USB_DEV_FEATURE_OTG_B_HNP_ENABLE = 3,
-  USB_DEV_FEATURE_OTG_A_HNP_SUPPORT = 4,
-  USB_DEV_FEATURE_OTG_A_ALT_HNP_SUPPORT = 5
+	USB_DEV_FEATURE_REMOTE_WAKEUP = 1, //!< Remote wakeup enabled
+	USB_DEV_FEATURE_TEST_MODE = 2,     //!< USB test mode
+	USB_DEV_FEATURE_OTG_B_HNP_ENABLE = 3,
+	USB_DEV_FEATURE_OTG_A_HNP_SUPPORT = 4,
+	USB_DEV_FEATURE_OTG_A_ALT_HNP_SUPPORT = 5
 };

 /**
@@ -166,54 +166,54 @@ enum usb_device_feature {
 * \note valid for USB_DEV_FEATURE_TEST_MODE request.
 */
 enum usb_device_hs_test_mode {
-  USB_DEV_TEST_MODE_J = 1,
-  USB_DEV_TEST_MODE_K = 2,
-  USB_DEV_TEST_MODE_SE0_NAK = 3,
-  USB_DEV_TEST_MODE_PACKET = 4,
-  USB_DEV_TEST_MODE_FORCE_ENABLE = 5,
+	USB_DEV_TEST_MODE_J = 1,
+	USB_DEV_TEST_MODE_K = 2,
+	USB_DEV_TEST_MODE_SE0_NAK = 3,
+	USB_DEV_TEST_MODE_PACKET = 4,
+	USB_DEV_TEST_MODE_FORCE_ENABLE = 5,
 };

 /**
 * \brief Standard USB endpoint feature/status flags
 */
 enum usb_endpoint_feature {
-  USB_EP_FEATURE_HALT = 0,
+	USB_EP_FEATURE_HALT = 0,
 };

 /**
 * \brief Standard USB Test Mode Selectors
 */
 enum usb_test_mode_selector {
-  USB_TEST_J = 0x01,
-  USB_TEST_K = 0x02,
-  USB_TEST_SE0_NAK = 0x03,
-  USB_TEST_PACKET = 0x04,
-  USB_TEST_FORCE_ENABLE = 0x05,
+	USB_TEST_J = 0x01,
+	USB_TEST_K = 0x02,
+	USB_TEST_SE0_NAK = 0x03,
+	USB_TEST_PACKET = 0x04,
+	USB_TEST_FORCE_ENABLE = 0x05,
 };

 /**
 * \brief Standard USB descriptor types
 */
 enum usb_descriptor_type {
-  USB_DT_DEVICE = 1,
-  USB_DT_CONFIGURATION = 2,
-  USB_DT_STRING = 3,
-  USB_DT_INTERFACE = 4,
-  USB_DT_ENDPOINT = 5,
-  USB_DT_DEVICE_QUALIFIER = 6,
-  USB_DT_OTHER_SPEED_CONFIGURATION = 7,
-  USB_DT_INTERFACE_POWER = 8,
-  USB_DT_OTG = 9,
-  USB_DT_IAD = 0x0B,
-  USB_DT_BOS = 0x0F,
-  USB_DT_DEVICE_CAPABILITY = 0x10,
+	USB_DT_DEVICE = 1,
+	USB_DT_CONFIGURATION = 2,
+	USB_DT_STRING = 3,
+	USB_DT_INTERFACE = 4,
+	USB_DT_ENDPOINT = 5,
+	USB_DT_DEVICE_QUALIFIER = 6,
+	USB_DT_OTHER_SPEED_CONFIGURATION = 7,
+	USB_DT_INTERFACE_POWER = 8,
+	USB_DT_OTG = 9,
+	USB_DT_IAD = 0x0B,
+	USB_DT_BOS = 0x0F,
+	USB_DT_DEVICE_CAPABILITY = 0x10,
 };

 /**
 * \brief USB Device Capability types
 */
 enum usb_capability_type {
-  USB_DC_USB20_EXTENSION = 0x02,
+	USB_DC_USB20_EXTENSION = 0x02,
 };

 /**
@@ -221,7 +221,7 @@ enum usb_capability_type {
 * To fill bmAttributes field of usb_capa_ext_desc_t structure.
 */
 enum usb_capability_extension_attr {
-  USB_DC_EXT_LPM  = 0x00000002,
+	USB_DC_EXT_LPM  = 0x00000002,
 };

 #define HIRD_50_US    0
@@ -254,18 +254,18 @@ enum usb_capability_extension_attr {
 * \brief Standard USB endpoint transfer types
 */
 enum usb_ep_type {
-  USB_EP_TYPE_CONTROL = 0x00,
-  USB_EP_TYPE_ISOCHRONOUS = 0x01,
-  USB_EP_TYPE_BULK = 0x02,
-  USB_EP_TYPE_INTERRUPT = 0x03,
-  USB_EP_TYPE_MASK = 0x03,
+	USB_EP_TYPE_CONTROL = 0x00,
+	USB_EP_TYPE_ISOCHRONOUS = 0x01,
+	USB_EP_TYPE_BULK = 0x02,
+	USB_EP_TYPE_INTERRUPT = 0x03,
+	USB_EP_TYPE_MASK = 0x03,
 };

 /**
 * \brief Standard USB language IDs for string descriptors
 */
 enum usb_langid {
-  USB_LANGID_EN_US = 0x0409, //!< English (United States)
+	USB_LANGID_EN_US = 0x0409, //!< English (United States)
 };

 /**
@@ -308,31 +308,31 @@ COMPILER_PACK_SET(1)
 * The data payload of SETUP packets always follows this structure.
 */
 typedef struct {
-  uint8_t bmRequestType;
-  uint8_t bRequest;
-  le16_t wValue;
-  le16_t wIndex;
-  le16_t wLength;
+	uint8_t bmRequestType;
+	uint8_t bRequest;
+	le16_t wValue;
+	le16_t wIndex;
+	le16_t wLength;
 } usb_setup_req_t;

 /**
 * \brief Standard USB device descriptor structure
 */
 typedef struct {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
-  le16_t bcdUSB;
-  uint8_t bDeviceClass;
-  uint8_t bDeviceSubClass;
-  uint8_t bDeviceProtocol;
-  uint8_t bMaxPacketSize0;
-  le16_t idVendor;
-  le16_t idProduct;
-  le16_t bcdDevice;
-  uint8_t iManufacturer;
-  uint8_t iProduct;
-  uint8_t iSerialNumber;
-  uint8_t bNumConfigurations;
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	le16_t bcdUSB;
+	uint8_t bDeviceClass;
+	uint8_t bDeviceSubClass;
+	uint8_t bDeviceProtocol;
+	uint8_t bMaxPacketSize0;
+	le16_t idVendor;
+	le16_t idProduct;
+	le16_t bcdDevice;
+	uint8_t iManufacturer;
+	uint8_t iProduct;
+	uint8_t iSerialNumber;
+	uint8_t bNumConfigurations;
 } usb_dev_desc_t;

 /**
@@ -344,15 +344,15 @@ typedef struct {
 * the device was operating at full speed.)
 */
 typedef struct {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
-  le16_t bcdUSB;
-  uint8_t bDeviceClass;
-  uint8_t bDeviceSubClass;
-  uint8_t bDeviceProtocol;
-  uint8_t bMaxPacketSize0;
-  uint8_t bNumConfigurations;
-  uint8_t bReserved;
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	le16_t bcdUSB;
+	uint8_t bDeviceClass;
+	uint8_t bDeviceSubClass;
+	uint8_t bDeviceProtocol;
+	uint8_t bMaxPacketSize0;
+	uint8_t bNumConfigurations;
+	uint8_t bReserved;
 } usb_dev_qual_desc_t;

 /**
@@ -368,10 +368,10 @@ typedef struct {
 * The descriptor type in the GetDescriptor() request is set to BOS.
 */
 typedef struct {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
-  le16_t  wTotalLength;
-  uint8_t bNumDeviceCaps;
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	le16_t  wTotalLength;
+	uint8_t bNumDeviceCaps;
 } usb_dev_bos_desc_t;


@@ -381,10 +381,10 @@ typedef struct {
 * Defines the set of USB 1.1-specific device level capabilities.
 */
 typedef struct {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
-  uint8_t bDevCapabilityType;
-  le32_t  bmAttributes;
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	uint8_t bDevCapabilityType;
+	le32_t  bmAttributes;
 } usb_dev_capa_ext_desc_t;

 /**
@@ -393,22 +393,22 @@ typedef struct {
 * The BOS descriptor and capabilities descriptors for LPM.
 */
 typedef struct {
-  usb_dev_bos_desc_t bos;
-  usb_dev_capa_ext_desc_t capa_ext;
+	usb_dev_bos_desc_t bos;
+	usb_dev_capa_ext_desc_t capa_ext;
 } usb_dev_lpm_desc_t;

 /**
 * \brief Standard USB Interface Association Descriptor structure
 */
 typedef struct {
-  uint8_t bLength;          //!< size of this descriptor in bytes
-  uint8_t bDescriptorType;  //!< INTERFACE descriptor type
-  uint8_t bFirstInterface;  //!< Number of interface
-  uint8_t bInterfaceCount;  //!< value to select alternate setting
-  uint8_t bFunctionClass;   //!< Class code assigned by the USB
-  uint8_t bFunctionSubClass;//!< Sub-class code assigned by the USB
-  uint8_t bFunctionProtocol;//!< Protocol code assigned by the USB
-  uint8_t iFunction;        //!< Index of string descriptor
+	uint8_t bLength;          //!< size of this descriptor in bytes
+	uint8_t bDescriptorType;  //!< INTERFACE descriptor type
+	uint8_t bFirstInterface;  //!< Number of interface
+	uint8_t bInterfaceCount;  //!< value to select alternate setting
+	uint8_t bFunctionClass;   //!< Class code assigned by the USB
+	uint8_t bFunctionSubClass;//!< Sub-class code assigned by the USB
+	uint8_t bFunctionProtocol;//!< Protocol code assigned by the USB
+	uint8_t iFunction;        //!< Index of string descriptor
 } usb_association_desc_t;


@@ -416,14 +416,14 @@ typedef struct {
 * \brief Standard USB configuration descriptor structure
 */
 typedef struct {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
-  le16_t wTotalLength;
-  uint8_t bNumInterfaces;
-  uint8_t bConfigurationValue;
-  uint8_t iConfiguration;
-  uint8_t bmAttributes;
-  uint8_t bMaxPower;
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	le16_t wTotalLength;
+	uint8_t bNumInterfaces;
+	uint8_t bConfigurationValue;
+	uint8_t iConfiguration;
+	uint8_t bmAttributes;
+	uint8_t bMaxPower;
 } usb_conf_desc_t;


@@ -438,41 +438,41 @@ typedef struct {
 * \brief Standard USB association descriptor structure
 */
 typedef struct {
-  uint8_t bLength;              //!< Size of this descriptor in bytes
-  uint8_t bDescriptorType;      //!< Interface descriptor type
-  uint8_t bFirstInterface;      //!< Number of interface
-  uint8_t bInterfaceCount;      //!< value to select alternate setting
-  uint8_t bFunctionClass;       //!< Class code assigned by the USB
-  uint8_t bFunctionSubClass;    //!< Sub-class code assigned by the USB
-  uint8_t bFunctionProtocol;    //!< Protocol code assigned by the USB
-  uint8_t iFunction;            //!< Index of string descriptor
+	uint8_t bLength;              //!< Size of this descriptor in bytes
+	uint8_t bDescriptorType;      //!< Interface descriptor type
+	uint8_t bFirstInterface;      //!< Number of interface
+	uint8_t bInterfaceCount;      //!< value to select alternate setting
+	uint8_t bFunctionClass;       //!< Class code assigned by the USB
+	uint8_t bFunctionSubClass;    //!< Sub-class code assigned by the USB
+	uint8_t bFunctionProtocol;    //!< Protocol code assigned by the USB
+	uint8_t iFunction;            //!< Index of string descriptor
 } usb_iad_desc_t;

 /**
 * \brief Standard USB interface descriptor structure
 */
 typedef struct {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
-  uint8_t bInterfaceNumber;
-  uint8_t bAlternateSetting;
-  uint8_t bNumEndpoints;
-  uint8_t bInterfaceClass;
-  uint8_t bInterfaceSubClass;
-  uint8_t bInterfaceProtocol;
-  uint8_t iInterface;
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	uint8_t bInterfaceNumber;
+	uint8_t bAlternateSetting;
+	uint8_t bNumEndpoints;
+	uint8_t bInterfaceClass;
+	uint8_t bInterfaceSubClass;
+	uint8_t bInterfaceProtocol;
+	uint8_t iInterface;
 } usb_iface_desc_t;

 /**
 * \brief Standard USB endpoint descriptor structure
 */
 typedef struct {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
-  uint8_t bEndpointAddress;
-  uint8_t bmAttributes;
-  le16_t wMaxPacketSize;
-  uint8_t bInterval;
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	uint8_t bEndpointAddress;
+	uint8_t bmAttributes;
+	le16_t wMaxPacketSize;
+	uint8_t bInterval;
 } usb_ep_desc_t;


@@ -480,13 +480,13 @@ typedef struct {
 * \brief A standard USB string descriptor structure
 */
 typedef struct {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
+	uint8_t bLength;
+	uint8_t bDescriptorType;
 } usb_str_desc_t;

 typedef struct {
-  usb_str_desc_t desc;
-  le16_t string[1];
+	usb_str_desc_t desc;
+	le16_t string[1];
 } usb_str_lgid_desc_t;

 COMPILER_PACK_RESET()
@@ -58,42 +58,42 @@
 * \name Possible values of class
 */
 //@{
-#define  CDC_CLASS_DEVICE     0x02  //!< USB Communication Device Class
-#define  CDC_CLASS_COMM       0x02  //!< CDC Communication Class Interface
-#define  CDC_CLASS_DATA       0x0A  //!< CDC Data Class Interface
+#define  CDC_CLASS_DEVICE     0x02	//!< USB Communication Device Class
+#define  CDC_CLASS_COMM       0x02	//!< CDC Communication Class Interface
+#define  CDC_CLASS_DATA       0x0A	//!< CDC Data Class Interface
 #define  CDC_CLASS_MULTI      0xEF      //!< CDC Multi-interface Function

 //@}

 //! \name USB CDC Subclass IDs
 //@{
-#define  CDC_SUBCLASS_DLCM    0x01  //!< Direct Line Control Model
-#define  CDC_SUBCLASS_ACM     0x02  //!< Abstract Control Model
-#define  CDC_SUBCLASS_TCM     0x03  //!< Telephone Control Model
-#define  CDC_SUBCLASS_MCCM    0x04  //!< Multi-Channel Control Model
-#define  CDC_SUBCLASS_CCM     0x05  //!< CAPI Control Model
-#define  CDC_SUBCLASS_ETH     0x06  //!< Ethernet Networking Control Model
-#define  CDC_SUBCLASS_ATM     0x07  //!< ATM Networking Control Model
+#define  CDC_SUBCLASS_DLCM    0x01	//!< Direct Line Control Model
+#define  CDC_SUBCLASS_ACM     0x02	//!< Abstract Control Model
+#define  CDC_SUBCLASS_TCM     0x03	//!< Telephone Control Model
+#define  CDC_SUBCLASS_MCCM    0x04	//!< Multi-Channel Control Model
+#define  CDC_SUBCLASS_CCM     0x05	//!< CAPI Control Model
+#define  CDC_SUBCLASS_ETH     0x06	//!< Ethernet Networking Control Model
+#define  CDC_SUBCLASS_ATM     0x07	//!< ATM Networking Control Model
 //@}

 //! \name USB CDC Communication Interface Protocol IDs
 //@{
-#define  CDC_PROTOCOL_V25TER  0x01  //!< Common AT commands
+#define  CDC_PROTOCOL_V25TER  0x01	//!< Common AT commands
 //@}

 //! \name USB CDC Data Interface Protocol IDs
 //@{
-#define  CDC_PROTOCOL_I430    0x30  //!< ISDN BRI
-#define  CDC_PROTOCOL_HDLC    0x31  //!< HDLC
-#define  CDC_PROTOCOL_TRANS   0x32  //!< Transparent
-#define  CDC_PROTOCOL_Q921M   0x50  //!< Q.921 management protocol
-#define  CDC_PROTOCOL_Q921    0x51  //!< Q.931 [sic] Data link protocol
-#define  CDC_PROTOCOL_Q921TM  0x52  //!< Q.921 TEI-multiplexor
-#define  CDC_PROTOCOL_V42BIS  0x90  //!< Data compression procedures
-#define  CDC_PROTOCOL_Q931    0x91  //!< Euro-ISDN protocol control
-#define  CDC_PROTOCOL_V120    0x92  //!< V.24 rate adaption to ISDN
-#define  CDC_PROTOCOL_CAPI20  0x93  //!< CAPI Commands
-#define  CDC_PROTOCOL_HOST    0xFD  //!< Host based driver
+#define  CDC_PROTOCOL_I430    0x30	//!< ISDN BRI
+#define  CDC_PROTOCOL_HDLC    0x31	//!< HDLC
+#define  CDC_PROTOCOL_TRANS   0x32	//!< Transparent
+#define  CDC_PROTOCOL_Q921M   0x50	//!< Q.921 management protocol
+#define  CDC_PROTOCOL_Q921    0x51	//!< Q.931 [sic] Data link protocol
+#define  CDC_PROTOCOL_Q921TM  0x52	//!< Q.921 TEI-multiplexor
+#define  CDC_PROTOCOL_V42BIS  0x90	//!< Data compression procedures
+#define  CDC_PROTOCOL_Q931    0x91	//!< Euro-ISDN protocol control
+#define  CDC_PROTOCOL_V120    0x92	//!< V.24 rate adaption to ISDN
+#define  CDC_PROTOCOL_CAPI20  0x93	//!< CAPI Commands
+#define  CDC_PROTOCOL_HOST    0xFD	//!< Host based driver
 /**
 * \brief Describes the Protocol Unit Functional Descriptors [sic]
 * on Communication Class Interface
@@ -103,16 +103,16 @@

 //! \name USB CDC Functional Descriptor Types
 //@{
-#define  CDC_CS_INTERFACE     0x24  //!< Interface Functional Descriptor
-#define  CDC_CS_ENDPOINT      0x25  //!< Endpoint Functional Descriptor
+#define  CDC_CS_INTERFACE     0x24	//!< Interface Functional Descriptor
+#define  CDC_CS_ENDPOINT      0x25	//!< Endpoint Functional Descriptor
 //@}

 //! \name USB CDC Functional Descriptor Subtypes
 //@{
-#define  CDC_SCS_HEADER       0x00  //!< Header Functional Descriptor
-#define  CDC_SCS_CALL_MGMT    0x01  //!< Call Management
-#define  CDC_SCS_ACM          0x02  //!< Abstract Control Management
-#define  CDC_SCS_UNION        0x06  //!< Union Functional Descriptor
+#define  CDC_SCS_HEADER       0x00	//!< Header Functional Descriptor
+#define  CDC_SCS_CALL_MGMT    0x01	//!< Call Management
+#define  CDC_SCS_ACM          0x02	//!< Abstract Control Management
+#define  CDC_SCS_UNION        0x06	//!< Union Functional Descriptor
 //@}

 //! \name USB CDC Request IDs
@@ -171,36 +171,36 @@ COMPILER_PACK_SET(1)

 //! CDC Header Functional Descriptor
 typedef struct {
-  uint8_t bFunctionLength;
-  uint8_t bDescriptorType;
-  uint8_t bDescriptorSubtype;
-  le16_t bcdCDC;
+	uint8_t bFunctionLength;
+	uint8_t bDescriptorType;
+	uint8_t bDescriptorSubtype;
+	le16_t bcdCDC;
 } usb_cdc_hdr_desc_t;

 //! CDC Call Management Functional Descriptor
 typedef struct {
-  uint8_t bFunctionLength;
-  uint8_t bDescriptorType;
-  uint8_t bDescriptorSubtype;
-  uint8_t bmCapabilities;
-  uint8_t bDataInterface;
+	uint8_t bFunctionLength;
+	uint8_t bDescriptorType;
+	uint8_t bDescriptorSubtype;
+	uint8_t bmCapabilities;
+	uint8_t bDataInterface;
 } usb_cdc_call_mgmt_desc_t;

 //! CDC ACM Functional Descriptor
 typedef struct {
-  uint8_t bFunctionLength;
-  uint8_t bDescriptorType;
-  uint8_t bDescriptorSubtype;
-  uint8_t bmCapabilities;
+	uint8_t bFunctionLength;
+	uint8_t bDescriptorType;
+	uint8_t bDescriptorSubtype;
+	uint8_t bmCapabilities;
 } usb_cdc_acm_desc_t;

 //! CDC Union Functional Descriptor
 typedef struct {
-  uint8_t bFunctionLength;
-  uint8_t bDescriptorType;
-  uint8_t bDescriptorSubtype;
-  uint8_t bMasterInterface;
-  uint8_t bSlaveInterface0;
+	uint8_t bFunctionLength;
+	uint8_t bDescriptorType;
+	uint8_t bDescriptorSubtype;
+	uint8_t bMasterInterface;
+	uint8_t bSlaveInterface0;
 } usb_cdc_union_desc_t;


@@ -235,24 +235,24 @@ typedef struct {
 //@{
 //! Line Coding structure
 typedef struct {
-  le32_t dwDTERate;
-  uint8_t bCharFormat;
-  uint8_t bParityType;
-  uint8_t bDataBits;
+	le32_t dwDTERate;
+	uint8_t bCharFormat;
+	uint8_t bParityType;
+	uint8_t bDataBits;
 } usb_cdc_line_coding_t;
 //! Possible values of bCharFormat
 enum cdc_char_format {
-  CDC_STOP_BITS_1 = 0,  //!< 1 stop bit
-  CDC_STOP_BITS_1_5 = 1,  //!< 1.5 stop bits
-  CDC_STOP_BITS_2 = 2,  //!< 2 stop bits
+	CDC_STOP_BITS_1 = 0,	//!< 1 stop bit
+	CDC_STOP_BITS_1_5 = 1,	//!< 1.5 stop bits
+	CDC_STOP_BITS_2 = 2,	//!< 2 stop bits
 };
 //! Possible values of bParityType
 enum cdc_parity {
-  CDC_PAR_NONE = 0, //!< No parity
-  CDC_PAR_ODD = 1,  //!< Odd parity
-  CDC_PAR_EVEN = 2, //!< Even parity
-  CDC_PAR_MARK = 3, //!< Parity forced to 0 (space)
-  CDC_PAR_SPACE = 4,  //!< Parity forced to 1 (mark)
+	CDC_PAR_NONE = 0,	//!< No parity
+	CDC_PAR_ODD = 1,	//!< Odd parity
+	CDC_PAR_EVEN = 2,	//!< Even parity
+	CDC_PAR_MARK = 3,	//!< Parity forced to 0 (space)
+	CDC_PAR_SPACE = 4,	//!< Parity forced to 1 (mark)
 };
 //@}

@@ -262,7 +262,7 @@ enum cdc_parity {

 //! Control signal structure
 typedef struct {
-  uint16_t value;
+	uint16_t value;
 } usb_cdc_control_signal_t;

 //! \name Possible values in usb_cdc_control_signal_t
@@ -283,11 +283,11 @@ typedef struct {
 //@{

 typedef struct {
-  uint8_t bmRequestType;
-  uint8_t bNotification;
-  le16_t wValue;
-  le16_t wIndex;
-  le16_t wLength;
+	uint8_t bmRequestType;
+	uint8_t bNotification;
+	le16_t wValue;
+	le16_t wIndex;
+	le16_t wLength;
 } usb_cdc_notify_msg_t;

 //! \name USB CDC serial state
@@ -295,8 +295,8 @@ typedef struct {

 //! Hardware handshake support (cdc spec 1.1 chapter 6.3.5)
 typedef struct {
-  usb_cdc_notify_msg_t header;
-  le16_t value;
+	usb_cdc_notify_msg_t header;
+	le16_t value;
 } usb_cdc_notify_serial_state_t;

 //! \name Possible values in usb_cdc_notify_serial_state_t
@@ -59,7 +59,7 @@
 * \name Possible Class value
 */
 //@{
-#define MSC_CLASS                   0x08
+#define  MSC_CLASS                  0x08
 //@}

 /**
@@ -71,12 +71,12 @@
 * operating systems like Windows XP.
 */
 //@{
-#define MSC_SUBCLASS_RBC            0x01  //!< Reduced Block Commands
-#define MSC_SUBCLASS_ATAPI          0x02  //!< CD/DVD devices
-#define MSC_SUBCLASS_QIC_157        0x03  //!< Tape devices
-#define MSC_SUBCLASS_UFI            0x04  //!< Floppy disk drives
-#define MSC_SUBCLASS_SFF_8070I      0x05  //!< Floppy disk drives
-#define MSC_SUBCLASS_TRANSPARENT    0x06  //!< Determined by INQUIRY
+#define  MSC_SUBCLASS_RBC           0x01	//!< Reduced Block Commands
+#define  MSC_SUBCLASS_ATAPI         0x02	//!< CD/DVD devices
+#define  MSC_SUBCLASS_QIC_157       0x03	//!< Tape devices
+#define  MSC_SUBCLASS_UFI           0x04	//!< Floppy disk drives
+#define  MSC_SUBCLASS_SFF_8070I     0x05	//!< Floppy disk drives
+#define  MSC_SUBCLASS_TRANSPARENT   0x06	//!< Determined by INQUIRY
 //@}

 /**
@@ -84,9 +84,9 @@
 * \note Only the BULK protocol should be used in new designs.
 */
 //@{
-#define MSC_PROTOCOL_CBI            0x00  //!< Command/Bulk/Interrupt
-#define MSC_PROTOCOL_CBI_ALT        0x01  //!< W/o command completion
-#define MSC_PROTOCOL_BULK           0x50  //!< Bulk-only
+#define  MSC_PROTOCOL_CBI           0x00	//!< Command/Bulk/Interrupt
+#define  MSC_PROTOCOL_CBI_ALT       0x01	//!< W/o command completion
+#define  MSC_PROTOCOL_BULK          0x50	//!< Bulk-only
 //@}


@@ -94,8 +94,8 @@
 * \brief MSC USB requests (bRequest)
 */
 enum usb_reqid_msc {
-  USB_REQ_MSC_BULK_RESET = 0xFF,  //!< Mass Storage Reset
-  USB_REQ_MSC_GET_MAX_LUN = 0xFE  //!< Get Max LUN
+	USB_REQ_MSC_BULK_RESET = 0xFF,	//!< Mass Storage Reset
+	USB_REQ_MSC_GET_MAX_LUN = 0xFE 	//!< Get Max LUN
 };


@@ -106,20 +106,20 @@ COMPILER_PACK_SET(1)
 */
 //@{
 struct usb_msc_cbw {
-  le32_t dCBWSignature; //!< Must contain 'USBC'
-  le32_t dCBWTag; //!< Unique command ID
-  le32_t dCBWDataTransferLength;  //!< Number of bytes to transfer
-  uint8_t bmCBWFlags; //!< Direction in bit 7
-  uint8_t bCBWLUN;  //!< Logical Unit Number
-  uint8_t bCBWCBLength; //!< Number of valid CDB bytes
-  uint8_t CDB[16];  //!< SCSI Command Descriptor Block
+	le32_t dCBWSignature;	//!< Must contain 'USBC'
+	le32_t dCBWTag;	//!< Unique command ID
+	le32_t dCBWDataTransferLength;	//!< Number of bytes to transfer
+	uint8_t bmCBWFlags;	//!< Direction in bit 7
+	uint8_t bCBWLUN;	//!< Logical Unit Number
+	uint8_t bCBWCBLength;	//!< Number of valid CDB bytes
+	uint8_t CDB[16];	//!< SCSI Command Descriptor Block
 };

-#define USB_CBW_SIGNATURE           0x55534243  //!< dCBWSignature value
-#define USB_CBW_DIRECTION_IN        (1<<7)  //!< Data from device to host
-#define USB_CBW_DIRECTION_OUT       (0<<7)  //!< Data from host to device
-#define USB_CBW_LUN_MASK            0x0F  //!< Valid bits in bCBWLUN
-#define USB_CBW_LEN_MASK            0x1F  //!< Valid bits in bCBWCBLength
+#define  USB_CBW_SIGNATURE          0x55534243	//!< dCBWSignature value
+#define  USB_CBW_DIRECTION_IN       (1<<7)	//!< Data from device to host
+#define  USB_CBW_DIRECTION_OUT      (0<<7)	//!< Data from host to device
+#define  USB_CBW_LUN_MASK           0x0F	//!< Valid bits in bCBWLUN
+#define  USB_CBW_LEN_MASK           0x1F	//!< Valid bits in bCBWCBLength
 //@}


@@ -128,16 +128,16 @@ struct usb_msc_cbw {
 */
 //@{
 struct usb_msc_csw {
-  le32_t dCSWSignature; //!< Must contain 'USBS'
-  le32_t dCSWTag; //!< Same as dCBWTag
-  le32_t dCSWDataResidue; //!< Number of bytes not transferred
-  uint8_t bCSWStatus; //!< Status code
+	le32_t dCSWSignature;	//!< Must contain 'USBS'
+	le32_t dCSWTag;	//!< Same as dCBWTag
+	le32_t dCSWDataResidue;	//!< Number of bytes not transferred
+	uint8_t bCSWStatus;	//!< Status code
 };

-#define USB_CSW_SIGNATURE           0x55534253  //!< dCSWSignature value
-#define USB_CSW_STATUS_PASS         0x00  //!< Command Passed
-#define USB_CSW_STATUS_FAIL         0x01  //!< Command Failed
-#define USB_CSW_STATUS_PE           0x02  //!< Phase Error
+#define  USB_CSW_SIGNATURE          0x55534253	//!< dCSWSignature value
+#define  USB_CSW_STATUS_PASS        0x00	//!< Command Passed
+#define  USB_CSW_STATUS_FAIL        0x01	//!< Command Failed
+#define  USB_CSW_STATUS_PE          0x02	//!< Phase Error
 //@}

 COMPILER_PACK_RESET()
@@ -51,18 +51,18 @@
 #include "conf_usb.h"
 #include "udc.h"

-#if HAS_MEDIA
+#if ENABLED(SDSUPPORT)
  static volatile bool main_b_msc_enable = false;
 #endif
 static volatile bool main_b_cdc_enable = false;
 static volatile bool main_b_dtr_active = false;

 void usb_task_idle(void) {
-  #if HAS_MEDIA
+  #if ENABLED(SDSUPPORT)
    // Attend SD card access from the USB MSD -- Prioritize access to improve speed
    int delay = 2;
    while (main_b_msc_enable && --delay > 0) {
-      if (udi_msc_process_trans()) delay = 20;
+      if (udi_msc_process_trans()) delay = 10000;

      // Reset the watchdog, just to be sure
      REG_WDT_CR = WDT_CR_WDRSTT | WDT_CR_KEY(0xA5);
@@ -70,7 +70,7 @@ void usb_task_idle(void) {
  #endif
 }

-#if HAS_MEDIA
+#if ENABLED(SDSUPPORT)
  bool usb_task_msc_enable(void)                { return ((main_b_msc_enable = true)); }
  void usb_task_msc_disable(void)               { main_b_msc_enable = false; }
  bool usb_task_msc_isenabled(void)             { return main_b_msc_enable; }
@@ -206,13 +206,13 @@ static USB_MicrosoftExtendedPropertiesDescriptor microsoft_extended_properties_d
 bool usb_task_extra_string(void) {
  static uint8_t udi_msft_magic[] = "MSFT100\xEE";
  static uint8_t udi_cdc_name[] = "CDC interface";
-  #if HAS_MEDIA
+  #if ENABLED(SDSUPPORT)
    static uint8_t udi_msc_name[] = "MSC interface";
  #endif

  struct extra_strings_desc_t {
    usb_str_desc_t header;
-    #if HAS_MEDIA
+    #if ENABLED(SDSUPPORT)
      le16_t string[Max(Max(sizeof(udi_cdc_name) - 1, sizeof(udi_msc_name) - 1), sizeof(udi_msft_magic) - 1)];
    #else
      le16_t string[Max(sizeof(udi_cdc_name) - 1, sizeof(udi_msft_magic) - 1)];
@@ -231,7 +231,7 @@ bool usb_task_extra_string(void) {
    str_lgt = sizeof(udi_cdc_name) - 1;
    str = udi_cdc_name;
    break;
-  #if HAS_MEDIA
+  #if ENABLED(SDSUPPORT)
    case UDI_MSC_STRING_ID:
      str_lgt = sizeof(udi_msc_name) - 1;
      str = udi_msc_name;
@@ -65,7 +65,6 @@ portMUX_TYPE MarlinHAL::spinlock = portMUX_INITIALIZER_UNLOCKED;
 // ------------------------

 uint16_t MarlinHAL::adc_result;
-pwm_pin_t MarlinHAL::pwm_pin_data[MAX_EXPANDER_BITS];

 // ------------------------
 // Private Variables
@@ -165,7 +164,7 @@ void MarlinHAL::init_board() {
 }

 void MarlinHAL::idletask() {
-  #if ALL(WIFISUPPORT, OTASUPPORT)
+  #if BOTH(WIFISUPPORT, OTASUPPORT)
    OTA_handle();
  #endif
  TERN_(ESP3D_WIFISUPPORT, esp3dlib.idletask());
@@ -331,37 +330,14 @@ int8_t get_pwm_channel(const pin_t pin, const uint32_t freq, const uint16_t res)
 }

 void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=_BV(PWM_RESOLUTION)-1*/, const bool invert/*=false*/) {
-  #if ENABLED(I2S_STEPPER_STREAM)
-    if (pin > 127) {
-      const uint8_t pinlo = pin & 0x7F;
-      pwm_pin_t &pindata = pwm_pin_data[pinlo];
-      const uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, pindata.pwm_cycle_ticks);
-      if (duty == 0 || duty == pindata.pwm_cycle_ticks) { // max or min (i.e., on/off)
-        pindata.pwm_duty_ticks = 0;  // turn off PWM for this pin
-        duty ? SBI32(i2s_port_data, pinlo) : CBI32(i2s_port_data, pinlo); // set pin level
-      }
-      else
-        pindata.pwm_duty_ticks = duty; // PWM duty count = # of 4µs ticks per full PWM cycle
-
-      return;
-    }
-  #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);
+    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) {
-  #if ENABLED(I2S_STEPPER_STREAM)
-    if (pin > 127) {
-      pwm_pin_data[pin & 0x7F].pwm_cycle_ticks = 1000000UL / f_desired / 4; // # of 4µs ticks per full PWM cycle
-      return 0;
-    }
-  #endif
-
  const int8_t cid = channel_for_pin(pin);
  if (cid >= 0) {
    if (f_desired == ledcReadFreq(cid)) return cid; // no freq change
@@ -50,25 +50,24 @@

 #define MYSERIAL1 flushableSerial

-#if ENABLED(ESP3D_WIFISUPPORT)
-  typedef ForwardSerial1Class< decltype(Serial2Socket) > DefaultSerial1;
-  extern DefaultSerial1 MSerial0;
-  #define MYSERIAL2 MSerial0
-#elif ENABLED(WIFISUPPORT)
-  #define MYSERIAL2 webSocketSerial
+#if EITHER(WIFISUPPORT, ESP3D_WIFISUPPORT)
+  #if ENABLED(ESP3D_WIFISUPPORT)
+    typedef ForwardSerial1Class< decltype(Serial2Socket) > DefaultSerial1;
+    extern DefaultSerial1 MSerial0;
+    #define MYSERIAL2 MSerial0
+  #else
+    #define MYSERIAL2 webSocketSerial
+  #endif
 #endif

-#define CRITICAL_SECTION_START() portENTER_CRITICAL(&hal.spinlock)
-#define CRITICAL_SECTION_END()   portEXIT_CRITICAL(&hal.spinlock)
+#define CRITICAL_SECTION_START() portENTER_CRITICAL(&spinlock)
+#define CRITICAL_SECTION_END()   portEXIT_CRITICAL(&spinlock)

 #define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment
 #define PWM_FREQUENCY  1000u   // Default PWM frequency when set_pwm_duty() is called without set_pwm_frequency()
 #define PWM_RESOLUTION   10u   // Default PWM bit resolution
 #define CHANNEL_MAX_NUM  15u   // max PWM channel # to allocate (7 to only use low speed, 15 to use low & high)
 #define MAX_PWM_IOPIN    33u   // hardware pwm pins < 34
-#ifndef MAX_EXPANDER_BITS
-  #define MAX_EXPANDER_BITS 32 // I2S expander bit width (max 32)
-#endif

 // ------------------------
 // Types
@@ -77,12 +76,6 @@
 typedef double isr_float_t;   // FPU ops are used for single-precision, so use double for ISRs.
 typedef int16_t pin_t;

-typedef struct pwm_pin {
-  uint32_t pwm_cycle_ticks = 1000000UL / (PWM_FREQUENCY) / 4; // # ticks per pwm cycle
-  uint32_t pwm_tick_count = 0;  // current tick count
-  uint32_t pwm_duty_ticks = 0;  // # of ticks for current duty cycle
-} pwm_pin_t;
-
 class Servo;
 typedef Servo hal_servo_t;

@@ -169,7 +162,7 @@ void _delay_ms(const int ms);
 // MarlinHAL Class
 // ------------------------

-#define HAL_ADC_VREF_MV   3300
+#define HAL_ADC_VREF         3.3
 #define HAL_ADC_RESOLUTION  10

 class MarlinHAL {
@@ -204,8 +197,6 @@ public:
  // Free SRAM
  static int freeMemory();

-  static pwm_pin_t pwm_pin_data[MAX_EXPANDER_BITS];
-
  //
  // ADC Methods
  //
@@ -53,7 +53,7 @@ static SPISettings spiConfig;
 // ------------------------

 void spiBegin() {
-  #if HAS_MEDIA && PIN_EXISTS(SD_SS)
+  #if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_SS)
    OUT_WRITE(SD_SS_PIN, HIGH);
  #endif
 }
@@ -42,33 +42,33 @@ void ICACHE_RAM_ATTR endstop_ISR() { endstops.update(); }

 void setup_endstop_interrupts() {
  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
-  TERN_(USE_X_MAX,       _ATTACH(X_MAX_PIN));
-  TERN_(USE_X_MIN,       _ATTACH(X_MIN_PIN));
-  TERN_(USE_Y_MAX,       _ATTACH(Y_MAX_PIN));
-  TERN_(USE_Y_MIN,       _ATTACH(Y_MIN_PIN));
-  TERN_(USE_Z_MAX,       _ATTACH(Z_MAX_PIN));
-  TERN_(USE_Z_MIN,       _ATTACH(Z_MIN_PIN));
-  TERN_(USE_X2_MAX,      _ATTACH(X2_MAX_PIN));
-  TERN_(USE_X2_MIN,      _ATTACH(X2_MIN_PIN));
-  TERN_(USE_Y2_MAX,      _ATTACH(Y2_MAX_PIN));
-  TERN_(USE_Y2_MIN,      _ATTACH(Y2_MIN_PIN));
-  TERN_(USE_Z2_MAX,      _ATTACH(Z2_MAX_PIN));
-  TERN_(USE_Z2_MIN,      _ATTACH(Z2_MIN_PIN));
-  TERN_(USE_Z3_MAX,      _ATTACH(Z3_MAX_PIN));
-  TERN_(USE_Z3_MIN,      _ATTACH(Z3_MIN_PIN));
-  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
-  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
-  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
-  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
-  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
-  TERN_(USE_J_MIN,       _ATTACH(J_MIN_PIN));
-  TERN_(USE_K_MAX,       _ATTACH(K_MAX_PIN));
-  TERN_(USE_K_MIN,       _ATTACH(K_MIN_PIN));
-  TERN_(USE_U_MAX,       _ATTACH(U_MAX_PIN));
-  TERN_(USE_U_MIN,       _ATTACH(U_MIN_PIN));
-  TERN_(USE_V_MAX,       _ATTACH(V_MAX_PIN));
-  TERN_(USE_V_MIN,       _ATTACH(V_MIN_PIN));
-  TERN_(USE_W_MAX,       _ATTACH(W_MAX_PIN));
-  TERN_(USE_W_MIN,       _ATTACH(W_MIN_PIN));
+  TERN_(HAS_X_MAX, _ATTACH(X_MAX_PIN));
+  TERN_(HAS_X_MIN, _ATTACH(X_MIN_PIN));
+  TERN_(HAS_Y_MAX, _ATTACH(Y_MAX_PIN));
+  TERN_(HAS_Y_MIN, _ATTACH(Y_MIN_PIN));
+  TERN_(HAS_Z_MAX, _ATTACH(Z_MAX_PIN));
+  TERN_(HAS_Z_MIN, _ATTACH(Z_MIN_PIN));
+  TERN_(HAS_X2_MAX, _ATTACH(X2_MAX_PIN));
+  TERN_(HAS_X2_MIN, _ATTACH(X2_MIN_PIN));
+  TERN_(HAS_Y2_MAX, _ATTACH(Y2_MAX_PIN));
+  TERN_(HAS_Y2_MIN, _ATTACH(Y2_MIN_PIN));
+  TERN_(HAS_Z2_MAX, _ATTACH(Z2_MAX_PIN));
+  TERN_(HAS_Z2_MIN, _ATTACH(Z2_MIN_PIN));
+  TERN_(HAS_Z3_MAX, _ATTACH(Z3_MAX_PIN));
+  TERN_(HAS_Z3_MIN, _ATTACH(Z3_MIN_PIN));
+  TERN_(HAS_Z4_MAX, _ATTACH(Z4_MAX_PIN));
+  TERN_(HAS_Z4_MIN, _ATTACH(Z4_MIN_PIN));
+  TERN_(HAS_Z_MIN_PROBE_PIN, _ATTACH(Z_MIN_PROBE_PIN));
+  TERN_(HAS_I_MAX, _ATTACH(I_MAX_PIN));
+  TERN_(HAS_I_MIN, _ATTACH(I_MIN_PIN));
+  TERN_(HAS_J_MAX, _ATTACH(J_MAX_PIN));
+  TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
+  TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
+  TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
+  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
+  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
+  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
+  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
+  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
+  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }
@@ -139,38 +139,22 @@ static void IRAM_ATTR i2s_intr_handler_default(void *arg) {
 }

 void stepperTask(void *parameter) {
-  uint32_t nextMainISR = 0;
-  #if ENABLED(LIN_ADVANCE)
-    uint32_t nextAdvanceISR = Stepper::LA_ADV_NEVER;
-  #endif
+  uint32_t remaining = 0;

-  for (;;) {
+  while (1) {
    xQueueReceive(dma.queue, &dma.current, portMAX_DELAY);
    dma.rw_pos = 0;

    while (dma.rw_pos < DMA_SAMPLE_COUNT) {
-      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
+      // Fill with the port data post pulse_phase until the next step
+      if (remaining) {
        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
+        remaining--;
+      }
+      else {
+        Stepper::pulse_phase_isr();
+        remaining = Stepper::block_phase_isr();
+      }
    }
  }
 }
@@ -353,26 +337,6 @@ uint8_t i2s_state(uint8_t pin) {
 }

 void i2s_push_sample() {
-  // Every 4µs (when space in DMA buffer) toggle each expander PWM output using
-  // the current duty cycle/frequency so they sync with any steps (once
-  // through the DMA/FIFO buffers).  PWM signal inversion handled by other functions
-  for (uint8_t p = 0; p < MAX_EXPANDER_BITS; ++p) {
-    if (hal.pwm_pin_data[p].pwm_duty_ticks > 0) { // pin has active pwm?
-      if (hal.pwm_pin_data[p].pwm_tick_count == 0) {
-        if (TEST32(i2s_port_data, p)) {  // hi->lo
-          CBI32(i2s_port_data, p);
-          hal.pwm_pin_data[p].pwm_tick_count = hal.pwm_pin_data[p].pwm_cycle_ticks - hal.pwm_pin_data[p].pwm_duty_ticks;
-        }
-        else { // lo->hi
-          SBI32(i2s_port_data, p);
-          hal.pwm_pin_data[p].pwm_tick_count = hal.pwm_pin_data[p].pwm_duty_ticks;
-        }
-      }
-      else
-        hal.pwm_pin_data[p].pwm_tick_count--;
-    }
-  }
-
  dma.current[dma.rw_pos++] = i2s_port_data;
 }

@@ -20,3 +20,7 @@
 *
 */
 #pragma once
+
+#if HAS_SPI_TFT || HAS_FSMC_TFT
+  #error "Sorry! TFT displays are not available for HAL/ESP32."
+#endif
@@ -20,10 +20,3 @@
 *
 */
 #pragma once
-
-//
-// Board-specific options need to be defined before HAL.h
-//
-#if MB(MKS_TINYBEE)
-  #define MAX_EXPANDER_BITS 24  // TinyBee has 3 x HC595
-#endif
@@ -21,26 +21,19 @@
 */
 #pragma once

-#if HAS_SPI_TFT || HAS_FSMC_TFT
-  #error "Sorry! TFT displays are not available for HAL/ESP32."
-#endif
-
 #if ENABLED(EMERGENCY_PARSER)
  #error "EMERGENCY_PARSER is not yet implemented for ESP32. Disable EMERGENCY_PARSER to continue."
 #endif

-#if ENABLED(SPINDLE_LASER_USE_PWM) && SPINDLE_LASER_FREQUENCY > 78125
-  #error "SPINDLE_LASER_FREQUENCY maximum value is 78125Hz for ESP32."
-#endif
-#if ENABLED(FAST_PWM_FAN) && FAST_PWM_FAN_FREQUENCY > 78125
-  #error "FAST_PWM_FREQUENCY maximum value is 78125Hz for ESP32."
+#if (ENABLED(SPINDLE_LASER_USE_PWM) && SPINDLE_LASER_FREQUENCY > 78125) || (ENABLED(FAST_PWM_FAN_FREQUENCY) && FAST_PWM_FAN_FREQUENCY > 78125)
+  #error "SPINDLE_LASER_FREQUENCY and FAST_PWM_FREQUENCY maximum value is 78125Hz for ESP32."
 #endif

 #if HAS_TMC_SW_SERIAL
  #error "TMC220x Software Serial is not supported on ESP32."
 #endif

-#if ALL(WIFISUPPORT, ESP3D_WIFISUPPORT)
+#if BOTH(WIFISUPPORT, ESP3D_WIFISUPPORT)
  #error "Only enable one WiFi option, either WIFISUPPORT or ESP3D_WIFISUPPORT."
 #endif

@@ -55,11 +48,3 @@
 #if USING_PULLDOWNS
  #error "PULLDOWN pin mode is not available on ESP32 boards."
 #endif
-
-#if ALL(I2S_STEPPER_STREAM, LIN_ADVANCE) && DISABLED(EXPERIMENTAL_I2S_LA)
-  #error "I2S stream is currently incompatible with LIN_ADVANCE."
-#endif
-
-#if ALL(I2S_STEPPER_STREAM, PRINTCOUNTER) && PRINTCOUNTER_SAVE_INTERVAL > 0 && DISABLED(PRINTCOUNTER_SYNC)
-  #error "PRINTCOUNTER_SAVE_INTERVAL may cause issues on ESP32 with an I2S expander. Define PRINTCOUNTER_SYNC in Configuration.h for an imperfect solution."
-#endif
@@ -22,7 +22,7 @@

 #include "../../inc/MarlinConfigPre.h"

-#if ALL(WIFISUPPORT, OTASUPPORT)
+#if BOTH(WIFISUPPORT, OTASUPPORT)

 #include <WiFi.h>
 #include <ESPmDNS.h>
@@ -50,7 +50,7 @@ void OTA_init() {
    })
    .onError([](ota_error_t error) {
      Serial.printf("Error[%u]: ", error);
-      const char *str = "unknown";
+      char *str;
      switch (error) {
        case OTA_AUTH_ERROR:    str = "Auth Failed";    break;
        case OTA_BEGIN_ERROR:   str = "Begin Failed";   break;
@@ -23,7 +23,7 @@

 #include "../../inc/MarlinConfigPre.h"

-#if ALL(WIFISUPPORT, WEBSUPPORT)
+#if BOTH(WIFISUPPORT, WEBSUPPORT)

 #include "../../core/serial.h"

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Scott Lahteine	f7406e233a	Only subtract home offsets for machine-centric XY	2022-07-17 15:18:57 -05:00
InsanityAutomation	8a12d0155c	Use raw positions for G34 probing to honor M206 offsets	2022-05-29 18:49:20 -04:00